/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using ForwardWindow5Stride2 = WindowStrideTest<Pair, 5, 2>;
TYPED_TEST_SUITE(ForwardWindow5Stride2, GTestTypeTriples);
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1755., 3080.,  3620.,  2205., 4420., 7325., 7975., 4660.,
      7360., 11875., 12525., 7180., 3213., 4940., 5180., 2799.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7325., 7975., 11875., 12525.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3429.,  3510.,  6010.,  6160.,  7060.,  7240.,  4293.,  4410.,
      8600.,  8840.,  14225., 14650., 15475., 15950., 9020.,  9320.,
      14270., 14720., 22975., 23750., 24225., 25050., 13850., 14360.,
      6093.,  6426.,  9310.,  9880.,  9760.,  10360., 5229.,  5598.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14225., 14650., 15475., 15950.,
                                         22975., 23750., 24225., 25050.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6777.,  6858.,  6939.,  7020.,  11870., 12020., 12170., 12320.,
      13940., 14120., 14300., 14480., 8469.,  8586.,  8703.,  8820.,
      16960., 17200., 17440., 17680., 28025., 28450., 28875., 29300.,
      30475., 30950., 31425., 31900., 17740., 18040., 18340., 18640.,
      28090., 28540., 28990., 29440., 45175., 45950., 46725., 47500.,
      47625., 48450., 49275., 50100., 27190., 27700., 28210., 28720.,
      11853., 12186., 12519., 12852., 18050., 18620., 19190., 19760.,
      18920., 19520., 20120., 20720., 10089., 10458., 10827., 11196.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28025., 28450., 28875., 29300., 30475., 30950., 31425., 31900.,
      45175., 45950., 46725., 47500., 47625., 48450., 49275., 50100.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13545., 23815., 28075., 17109., 34475., 57125., 62225., 36335.,
      57575., 92825., 97925., 56075., 24885., 38155., 40015., 21537.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57125., 62225., 92825., 97925.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26775.,  27090.,  47045.,  47630.,  55445.,  56150.,  33759.,  34218.,
      68005.,  68950.,  112575., 114250., 122575., 124450., 71485.,  72670.,
      113365., 115150., 182575., 185650., 192575., 195850., 110125., 112150.,
      48447.,  49770.,  74045.,  76310.,  77645.,  80030.,  41607.,  43074.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {112575., 114250., 122575., 124450.,
                                         182575., 185650., 192575., 195850.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      53235.,  53550.,  53865.,  54180.,  93505.,  94090.,  94675.,  95260.,
      110185., 110890., 111595., 112300., 67059.,  67518.,  67977.,  68436.,
      135065., 136010., 136955., 137900., 223475., 225150., 226825., 228500.,
      243275., 245150., 247025., 248900., 141785., 142970., 144155., 145340.,
      224945., 226730., 228515., 230300., 362075., 365150., 368225., 371300.,
      381875., 385150., 388425., 391700., 218225., 220250., 222275., 224300.,
      95571.,  96894.,  98217.,  99540.,  145825., 148090., 150355., 152620.,
      152905., 155290., 157675., 160060., 81747.,  83214.,  84681.,  86148.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      223475., 225150., 226825., 228500., 243275., 245150., 247025., 248900.,
      362075., 365150., 368225., 371300., 381875., 385150., 388425., 391700.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      106398., 187250., 221090., 134766., 272290., 451150., 491550., 286930.,
      455410., 733950., 774350., 443170., 195822., 299810., 314450., 168894.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {451150., 491550., 733950., 774350.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      211554.,  212796., 372190., 374500., 439390.,  442180.,  267714.,
      269532.,  540830., 544580., 895650., 902300.,  975650.,  983100.,
      569150.,  573860., 903710., 910820., 1455650., 1467900., 1535650.,
      1548700., 878270., 886340., 386370., 391644.,  590590.,  599620.,
      619390.,  628900., 331938., 337788.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {895650.,  902300.,  975650.,
                                         983100.,  1455650., 1467900.,
                                         1535650., 1548700.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      421866.,  423108.,  424350.,  425592.,  742070.,  744380.,  746690.,
      749000.,  875990.,  878780.,  881570.,  884360.,  533610.,  535428.,
      537246.,  539064.,  1077910., 1081660., 1085410., 1089160., 1784650.,
      1791300., 1797950., 1804600., 1943850., 1951300., 1958750., 1966200.,
      1133590., 1138300., 1143010., 1147720., 1800310., 1807420., 1814530.,
      1821640., 2899050., 2911300., 2923550., 2935800., 3058250., 3071300.,
      3084350., 3097400., 1748470., 1756540., 1764610., 1772680., 767466.,
      772740.,  778014.,  783288.,  1172150., 1181180., 1190210., 1199240.,
      1229270., 1238780., 1248290., 1257800., 658026.,  663876.,  669726.,
      675576.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1784650., 1791300., 1797950., 1804600., 1943850., 1951300.,
      1958750., 1966200., 2899050., 2911300., 2923550., 2935800.,
      3058250., 3071300., 3084350., 3097400.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2666.,  3670.,  4210.,  2541., 6620., 8550., 9200., 5350.,
      10940., 13750., 14400., 8230., 4670., 5710., 5950., 3207.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8225., 8875., 13425., 14075.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5206.,  5332.,  7160.,  7340.,  8210.,  8420.,  4947.,  5082.,
      12870., 13240., 16600., 17100., 17850., 18400., 10355., 10700.,
      21190., 21880., 26600., 27500., 27850., 28800., 15875., 16460.,
      8830.,  9340.,  10760., 11420., 11210., 11900., 5991.,  6414.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15975., 16450., 17225., 17750.,
                                         25975., 26850., 27225., 28150.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10286., 10412., 10538., 10664., 14140., 14320., 14500., 14680.,
      16210., 16420., 16630., 16840., 9759.,  9894.,  10029., 10164.,
      25370., 25740., 26110., 26480., 32700., 33200., 33700., 34200.,
      35150., 35700., 36250., 36800., 20365., 20710., 21055., 21400.,
      41690., 42380., 43070., 43760., 52300., 53200., 54100., 55000.,
      54750., 55700., 56650., 57600., 31165., 31750., 32335., 32920.,
      17150., 17660., 18170., 18680., 20860., 21520., 22180., 22840.,
      21730., 22420., 23110., 23800., 11559., 11982., 12405., 12828.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31475., 31950., 32425., 32900., 33925., 34450., 34975., 35500.,
      51075., 51950., 52825., 53700., 53525., 54450., 55375., 56300.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20644., 28475.,  32735.,  19761., 51700., 66775., 71875., 41765.,
      85620., 107575., 112675., 64325., 36148., 44135., 45995., 24693.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {64225., 69325., 105025., 110125.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      40796.,  41288.,  56245.,  56950.,  64645.,  65470.,  38991.,  39522.,
      101940., 103400., 131575., 133550., 141575., 143750., 82165.,  83530.,
      168500., 171240., 211575., 215150., 221575., 225350., 126325., 128650.,
      70268.,  72296.,  85645.,  88270.,  89245.,  91990.,  47703.,  49386.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {126575., 128450., 136575., 138650.,
                                         206575., 210050., 216575., 220250.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      81100.,  81592.,  82084.,  82576.,  111785., 112490., 113195., 113900.,
      128465., 129290., 130115., 130940., 77451.,  77982.,  78513.,  79044.,
      202420., 203880., 205340., 206800., 261175., 263150., 265125., 267100.,
      280975., 283150., 285325., 287500., 162965., 164330., 165695., 167060.,
      334260., 337000., 339740., 342480., 419575., 423150., 426725., 430300.,
      439375., 443150., 446925., 450700., 250325., 252650., 254975., 257300.,
      138508., 140536., 142564., 144592., 168665., 171290., 173915., 176540.,
      175745., 178490., 181235., 183980., 93723.,  95406.,  97089.,  98772.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      251275., 253150., 255025., 256900., 271075., 273150., 275225., 277300.,
      409675., 413150., 416625., 420100., 429475., 433150., 436825., 440500.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      162440., 224290., 258130., 155838., 408600., 527750., 568150., 330010.,
      677400., 850950., 891350., 508570., 284360., 346930., 361570., 193710.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {507550., 547950., 830750., 871150.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      322936.,  324880.,  445790.,  448580.,  512990.,  516260.,  309570.,
      311676.,  811400.,  817200.,  1047650., 1055500., 1127650., 1136300.,
      654590.,  660020.,  1343880., 1354800., 1687650., 1701900., 1767650.,
      1782700., 1007870., 1017140., 560632.,  568720.,  683390.,  693860.,
      712190.,  723140.,  380706.,  387420.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1007650., 1015100., 1087650.,
                                         1095900., 1647650., 1661500.,
                                         1727650., 1742300.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      643928.,  645872.,  647816.,  649760.,  888790.,  891580.,  894370.,
      897160.,  1022710., 1025980., 1029250., 1032520., 617034.,  619140.,
      621246.,  623352.,  1617000., 1622800., 1628600., 1634400., 2087450.,
      2095300., 2103150., 2111000., 2246650., 2255300., 2263950., 2272600.,
      1303750., 1309180., 1314610., 1320040., 2676840., 2687760., 2698680.,
      2709600., 3361050., 3375300., 3389550., 3403800., 3520250., 3535300.,
      3550350., 3565400., 2006470., 2015740., 2025010., 2034280., 1113176.,
      1121264., 1129352., 1137440., 1356310., 1366780., 1377250., 1387720.,
      1413430., 1424380., 1435330., 1446280., 754698.,  761412.,  768126.,
      774840.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2007850., 2015300., 2022750., 2030200., 2167050., 2175300.,
      2183550., 2191800., 3281450., 3295300., 3309150., 3323000.,
      3440650., 3455300., 3469950., 3484600.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3190.,  4310.,  4850.,  5390.,  3213.,
                                         8100.,  10350., 11000., 11650., 6730.,
                                         13500., 16850., 17500., 18150., 10330.,
                                         5770.,  7010.,  7250.,  7490.,  4023.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10025., 10675., 11325.,
                                         16525., 17175., 17825.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6230.,  6380.,  8410.,  8620.,  9460.,  9700.,  10510., 10780.,
      6255.,  6426.,  15750., 16200., 20100., 20700., 21350., 22000.,
      22600., 23300., 13025., 13460., 26150., 27000., 32600., 33700.,
      33850., 35000., 35100., 36300., 19925., 20660., 10910., 11540.,
      13210., 14020., 13660., 14500., 14110., 14980., 7515.,  8046.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19475., 20050., 20725., 21350.,
                                         21975., 22650., 31975., 33050.,
                                         33225., 34350., 34475., 35650.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12310., 12460., 12610., 12760., 16610., 16820., 17030., 17240., 18680.,
      18920., 19160., 19400., 20750., 21020., 21290., 21560., 12339., 12510.,
      12681., 12852., 31050., 31500., 31950., 32400., 39600., 40200., 40800.,
      41400., 42050., 42700., 43350., 44000., 44500., 45200., 45900., 46600.,
      25615., 26050., 26485., 26920., 51450., 52300., 53150., 54000., 64100.,
      65200., 66300., 67400., 66550., 67700., 68850., 70000., 69000., 70200.,
      71400., 72600., 39115., 39850., 40585., 41320., 21190., 21820., 22450.,
      23080., 25610., 26420., 27230., 28040., 26480., 27320., 28160., 29000.,
      27350., 28220., 29090., 29960., 14499., 15030., 15561., 16092.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38375., 38950., 39525., 40100., 40825., 41450., 42075., 42700.,
      43275., 43950., 44625., 45300., 62875., 63950., 65025., 66100.,
      65325., 66450., 67575., 68700., 67775., 68950., 70125., 71300.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24788., 33535., 37795., 42055.,  25065.,  63380.,  80975.,
      86075., 91175., 52625., 105780., 131975., 137075., 142175.,
      80825., 44708., 54235., 56095.,  57955.,  31005.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {78425.,  83525.,  88625.,
                                         129425., 134525., 139625.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48988.,  49576.,  66245.,  67070.,  74645.,  75590.,  83045.,  84110.,
      49455.,  50130.,  124980., 126760., 159575., 161950., 169575., 172150.,
      179575., 182350., 103525., 105250., 208180., 211560., 259575., 263950.,
      269575., 274150., 279575., 284350., 158725., 161650., 86908.,  89416.,
      105245., 108470., 108845., 112190., 112445., 115910., 59895.,  62010.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {154575., 156850., 164575., 167050.,
                                         174575., 177250., 254575., 258850.,
                                         264575., 269050., 274575., 279250.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97388.,  97976.,  98564.,  99152.,  131665., 132490., 133315., 134140.,
      148345., 149290., 150235., 151180., 165025., 166090., 167155., 168220.,
      98235.,  98910.,  99585.,  100260., 248180., 249960., 251740., 253520.,
      316775., 319150., 321525., 323900., 336575., 339150., 341725., 344300.,
      356375., 359150., 361925., 364700., 205325., 207050., 208775., 210500.,
      412980., 416360., 419740., 423120., 514775., 519150., 523525., 527900.,
      534575., 539150., 543725., 548300., 554375., 559150., 563925., 568700.,
      314525., 317450., 320375., 323300., 171308., 173816., 176324., 178832.,
      207265., 210490., 213715., 216940., 214345., 217690., 221035., 224380.,
      221425., 224890., 228355., 231820., 117675., 119790., 121905., 124020.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      306875., 309150., 311425., 313700., 326675., 329150., 331625., 334100.,
      346475., 349150., 351825., 354500., 504875., 509150., 513425., 517700.,
      524675., 529150., 533625., 538100., 544475., 549150., 553825., 558500.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      195400., 264530., 298370., 332210., 197982.,  501400.,  640550.,
      680950., 721350., 416170., 837400., 1044550., 1084950., 1125350.,
      639370., 351880., 426530., 441170., 455810.,  243342.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {620350.,  660750.,  701150.,
                                         1024350., 1064750., 1105150.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      388472.,  390800.,  525790.,  529060.,  592990.,  596740.,  660190.,
      664420.,  393282.,  395964.,  995720.,  1002800., 1271650., 1281100.,
      1351650., 1361900., 1431650., 1442700., 825470.,  832340.,  1661320.,
      1674800., 2071650., 2089100., 2151650., 2169900., 2231650., 2250700.,
      1267070., 1278740., 693752.,  703760.,  840190.,  853060.,  868990.,
      882340.,  897790.,  911620.,  478242.,  486684.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1231650., 1240700., 1311650., 1321500., 1391650., 1402300.,
      2031650., 2048700., 2111650., 2129500., 2191650., 2210300.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x7x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      774616.,  776944.,  779272.,  781600.,  1048310., 1051580., 1054850.,
      1058120., 1182230., 1185980., 1189730., 1193480., 1316150., 1320380.,
      1324610., 1328840., 783882.,  786564.,  789246.,  791928.,  1984360.,
      1991440., 1998520., 2005600., 2533850., 2543300., 2552750., 2562200.,
      2693050., 2703300., 2713550., 2723800., 2852250., 2863300., 2874350.,
      2885400., 1644070., 1650940., 1657810., 1664680., 3309160., 3322640.,
      3336120., 3349600., 4125850., 4143300., 4160750., 4178200., 4285050.,
      4303300., 4321550., 4339800., 4444250., 4463300., 4482350., 4501400.,
      2522470., 2534140., 2545810., 2557480., 1377496., 1387504., 1397512.,
      1407520., 1667510., 1680380., 1693250., 1706120., 1724630., 1737980.,
      1751330., 1764680., 1781750., 1795580., 1809410., 1823240., 948042.,
      956484.,  964926.,  973368.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x7x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2454250., 2463300., 2472350., 2481400., 2613450., 2623300.,
      2633150., 2643000., 2772650., 2783300., 2793950., 2804600.,
      4046250., 4063300., 4080350., 4097400., 4205450., 4223300.,
      4241150., 4259000., 4364650., 4383300., 4401950., 4420600.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3008., 5100.,  5720.,  3404., 5890., 9600., 10250., 5920.,
      8830., 14150., 14800., 8440., 3780., 5780., 6020.,  3240.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7325., 7975., 11875., 12525.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5866.,  6016.,  9930.,  10200., 11130., 11440., 6610.,  6808.,
      11435., 11780., 18600., 19200., 19850., 20500., 11435., 11840.,
      17105., 17660., 27350., 28300., 28600., 29600., 16265., 16880.,
      7164.,  7560.,  10885., 11560., 11335., 12040., 6048.,  6480.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14225., 14650., 15475., 15950.,
                                         22975., 23750., 24225., 25050.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11582., 11732., 11882., 12032., 19590., 19860., 20130., 20400.,
      21950., 22260., 22570., 22880., 13022., 13220., 13418., 13616.,
      22525., 22870., 23215., 23560., 36600., 37200., 37800., 38400.,
      39050., 39700., 40350., 41000., 22465., 22870., 23275., 23680.,
      33655., 34210., 34765., 35320., 53750., 54700., 55650., 56600.,
      56200., 57200., 58200., 59200., 31915., 32530., 33145., 33760.,
      13932., 14328., 14724., 15120., 21095., 21770., 22445., 23120.,
      21965., 22670., 23375., 24080., 11664., 12096., 12528., 12960.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28025., 28450., 28875., 29300., 30475., 30950., 31425., 31900.,
      45175., 45950., 46725., 47500., 47625., 48450., 49275., 50100.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23380., 39660.,  44540.,  26500., 46025., 74975., 80075., 46205.,
      69125., 110675., 115775., 65945., 29295., 44665., 46525., 24939.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57125., 62225., 92825., 97925.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46172.,  46760.,  78260.,  79320.,  87860.,  89080.,  52220.,  53000.,
      90685.,  92050.,  147575., 149950., 157575., 160150., 90805.,  92410.,
      136045., 138250., 217575., 221350., 227575., 231550., 129445., 131890.,
      57015.,  58590.,  86645.,  89330.,  90245.,  93050.,  48159.,  49878.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {112575., 114250., 122575., 124450.,
                                         182575., 185650., 192575., 195850.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      91756.,  92344.,  92932.,  93520.,  155460., 156520., 157580., 158640.,
      174500., 175720., 176940., 178160., 103660., 104440., 105220., 106000.,
      180005., 181370., 182735., 184100., 292775., 295150., 297525., 299900.,
      312575., 315150., 317725., 320300., 180005., 181610., 183215., 184820.,
      269885., 272090., 274295., 276500., 431375., 435150., 438925., 442700.,
      451175., 455150., 459125., 463100., 256445., 258890., 261335., 263780.,
      112455., 114030., 115605., 117180., 170605., 173290., 175975., 178660.,
      177685., 180490., 183295., 186100., 94599.,  96318.,  98037.,  99756.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      223475., 225150., 226825., 228500., 243275., 245150., 247025., 248900.,
      362075., 365150., 368225., 371300., 381875., 385150., 388425., 391700.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184328., 312760., 351480., 209096., 363850., 592550., 632950., 365050.,
      546970., 875350., 915750., 521290., 230598., 351050., 365690., 195606.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {451150., 491550., 733950., 774350.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      366328.,  368656.,  621320.,  625520.,  698120.,  702960.,  415096.,
      418192.,  722270.,  727700.,  1175650., 1185100., 1255650., 1265900.,
      723710.,  730100.,  1085150., 1093940., 1735650., 1750700., 1815650.,
      1831500., 1032830., 1042580., 454914.,  461196.,  691390.,  702100.,
      720190.,  731380.,  384354.,  391212.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {895650.,  902300.,  975650.,
                                         983100.,  1455650., 1467900.,
                                         1535650., 1548700.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      730328.,  732656.,  734984.,  737312.,  1238440., 1242640., 1246840.,
      1251040., 1391400., 1396240., 1401080., 1405920., 827096.,  830192.,
      833288.,  836384.,  1439110., 1444540., 1449970., 1455400., 2341850.,
      2351300., 2360750., 2370200., 2501050., 2511300., 2521550., 2531800.,
      1441030., 1447420., 1453810., 1460200., 2161510., 2170300., 2179090.,
      2187880., 3456250., 3471300., 3486350., 3501400., 3615450., 3631300.,
      3647150., 3663000., 2055910., 2065660., 2075410., 2085160., 903546.,
      909828.,  916110.,  922392.,  1372070., 1382780., 1393490., 1404200.,
      1429190., 1440380., 1451570., 1462760., 761850.,  768708.,  775566.,
      782424.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1784650., 1791300., 1797950., 1804600., 1943850., 1951300.,
      1958750., 1966200., 2899050., 2911300., 2923550., 2935800.,
      3058250., 3071300., 3084350., 3097400.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4532.,  6000.,  6620.,  3914., 8780., 11150., 11800., 6790.,
      13100., 16350., 17000., 9670., 5486., 6670.,  6910.,  3711.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8225., 8875., 13425., 14075.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8832.,  9064.,  11680., 12000., 12880., 13240., 7600.,  7828.,
      17030., 17560., 21600., 22300., 22850., 23600., 13115., 13580.,
      25350., 26200., 31600., 32700., 32850., 34000., 18635., 19340.,
      10366., 10972., 12560., 13340., 13010., 13820., 6927.,  7422.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15975., 16450., 17225., 17750.,
                                         25975., 26850., 27225., 28150.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17432., 17664., 17896., 18128., 23040., 23360., 23680., 24000.,
      25400., 25760., 26120., 26480., 14972., 15200., 15428., 15656.,
      33530., 34060., 34590., 35120., 42500., 43200., 43900., 44600.,
      44950., 45700., 46450., 47200., 25765., 26230., 26695., 27160.,
      49850., 50700., 51550., 52400., 62100., 63200., 64300., 65400.,
      64550., 65700., 66850., 68000., 36565., 37270., 37975., 38680.,
      20126., 20732., 21338., 21944., 24340., 25120., 25900., 26680.,
      25210., 26020., 26830., 27640., 13359., 13854., 14349., 14844.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31475., 31950., 32425., 32900., 33925., 34450., 34975., 35500.,
      51075., 51950., 52825., 53700., 53525., 54450., 55375., 56300.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35296.,  46760.,  51640.,  30520., 68660., 87175., 92275., 53045.,
      102580., 127975., 133075., 75605., 42484., 51575., 53435., 28581.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {64225., 69325., 105025., 110125.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69680.,  70592.,  92260.,  93520.,  101860., 103280., 60140.,  61040.,
      135220., 137320., 171575., 174350., 181575., 184550., 104245., 106090.,
      201780., 205160., 251575., 255950., 261575., 266150., 148405., 151210.,
      82556.,  84968.,  100045., 103150., 103645., 106870., 55191.,  57162.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {126575., 128450., 136575., 138650.,
                                         206575., 210050., 216575., 220250.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      138448., 139360., 140272., 141184., 183260., 184520., 185780., 187040.,
      202300., 203720., 205140., 206560., 119380., 120280., 121180., 122080.,
      268340., 270440., 272540., 274640., 340375., 343150., 345925., 348700.,
      360175., 363150., 366125., 369100., 206645., 208490., 210335., 212180.,
      400180., 403560., 406940., 410320., 498775., 503150., 507525., 511900.,
      518575., 523150., 527725., 532300., 294005., 296810., 299615., 302420.,
      162700., 165112., 167524., 169936., 196985., 200090., 203195., 206300.,
      204065., 207290., 210515., 213740., 108411., 110382., 112353., 114324.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      251275., 253150., 255025., 256900., 271075., 273150., 275225., 277300.,
      409675., 413150., 416625., 420100., 429475., 433150., 436825., 440500.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      278560., 369160.,  407880.,  241016., 543000., 689350., 729750., 419290.,
      811800., 1012550., 1052950., 597850., 334280., 405490., 420130., 224238.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {507550., 547950., 830750., 871150.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      553504.,  557120.,  733320.,  738320.,  810120.,  815760.,  478456.,
      482032.,  1077640., 1086000., 1367650., 1378700., 1447650., 1459500.,
      831230.,  838580.,  1610120., 1623600., 2007650., 2025100., 2087650.,
      2105900., 1184510., 1195700., 658936.,  668560.,  798590.,  810980.,
      827390.,  840260.,  440610.,  448476.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1007650., 1015100., 1087650.,
                                         1095900., 1647650., 1661500.,
                                         1727650., 1742300.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1103392., 1107008., 1110624., 1114240., 1461640., 1466640., 1471640.,
      1476640., 1614600., 1620240., 1625880., 1631520., 953336.,  956912.,
      960488.,  964064.,  2146920., 2155280., 2163640., 2172000., 2724250.,
      2735300., 2746350., 2757400., 2883450., 2895300., 2907150., 2919000.,
      1655110., 1662460., 1669810., 1677160., 3206760., 3220240., 3233720.,
      3247200., 3997850., 4015300., 4032750., 4050200., 4157050., 4175300.,
      4193550., 4211800., 2357830., 2369020., 2380210., 2391400., 1308248.,
      1317872., 1327496., 1337120., 1584790., 1597180., 1609570., 1621960.,
      1641910., 1654780., 1667650., 1680520., 873354.,  881220.,  889086.,
      896952.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2007850., 2015300., 2022750., 2030200., 2167050., 2175300.,
      2183550., 2191800., 3281450., 3295300., 3309150., 3323000.,
      3440650., 3455300., 3469950., 3484600.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5500.,  7180.,  7800.,  8420.,  4934.,
                                         10800., 13600., 14250., 14900., 8530.,
                                         16200., 20100., 20750., 21400., 12130.,
                                         6790.,  8210.,  8450.,  8690.,  4653.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10025., 10675., 11325.,
                                         16525., 17175., 17825.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10720., 11000., 13980., 14360., 15180., 15600., 16380., 16840.,
      9580.,  9868.,  20950., 21600., 26350., 27200., 27600., 28500.,
      28850., 29800., 16475., 17060., 31350., 32400., 38850., 40200.,
      40100., 41500., 41350., 42800., 23375., 24260., 12830., 13580.,
      15460., 16420., 15910., 16900., 16360., 17380., 8685.,  9306.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {19475., 20050., 20725., 21350.,
                                         21975., 22650., 31975., 33050.,
                                         33225., 34350., 34475., 35650.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21160., 21440., 21720., 22000., 27580., 27960., 28340., 28720., 29940.,
      30360., 30780., 31200., 32300., 32760., 33220., 33680., 18872., 19160.,
      19448., 19736., 41250., 41900., 42550., 43200., 51850., 52700., 53550.,
      54400., 54300., 55200., 56100., 57000., 56750., 57700., 58650., 59600.,
      32365., 32950., 33535., 34120., 61650., 62700., 63750., 64800., 76350.,
      77700., 79050., 80400., 78800., 80200., 81600., 83000., 81250., 82700.,
      84150., 85600., 45865., 46750., 47635., 48520., 24910., 25660., 26410.,
      27160., 29960., 30920., 31880., 32840., 30830., 31820., 32810., 33800.,
      31700., 32720., 33740., 34760., 16749., 17370., 17991., 18612.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38375., 38950., 39525., 40100., 40825., 41450., 42075., 42700.,
      43275., 43950., 44625., 45300., 62875., 63950., 65025., 66100.,
      65325., 66450., 67575., 68700., 67775., 68950., 70125., 71300.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42944.,  56080.,  60960., 65840.,  38560.,  84580.,  106475.,
      111575., 116675., 66725., 126980., 157475., 162575., 167675.,
      94925.,  52628.,  63535., 65395.,  67255.,  35865.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {78425.,  83525.,  88625.,
                                         129425., 134525., 139625.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84784.,  85888.,  110660., 112160., 120260., 121920., 129860., 131680.,
      75980.,  77120.,  166580., 169160., 209575., 212950., 219575., 223150.,
      229575., 233350., 131125., 133450., 249780., 253960., 309575., 314950.,
      319575., 325150., 329575., 335350., 186325., 189850., 102268., 105256.,
      123245., 127070., 126845., 130790., 130445., 134510., 69255.,  71730.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {154575., 156850., 164575., 167050.,
                                         174575., 177250., 254575., 258850.,
                                         264575., 269050., 274575., 279250.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      168464., 169568., 170672., 171776., 219820., 221320., 222820., 224320.,
      238860., 240520., 242180., 243840., 257900., 259720., 261540., 263360.,
      150820., 151960., 153100., 154240., 330580., 333160., 335740., 338320.,
      415775., 419150., 422525., 425900., 435575., 439150., 442725., 446300.,
      455375., 459150., 462925., 466700., 259925., 262250., 264575., 266900.,
      495380., 499560., 503740., 507920., 613775., 619150., 624525., 629900.,
      633575., 639150., 644725., 650300., 653375., 659150., 664925., 670700.,
      369125., 372650., 376175., 379700., 201548., 204536., 207524., 210512.,
      242665., 246490., 250315., 254140., 249745., 253690., 257635., 261580.,
      256825., 260890., 264955., 269020., 136035., 138510., 140985., 143460.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      306875., 309150., 311425., 313700., 326675., 329150., 331625., 334100.,
      346475., 349150., 351825., 354500., 504875., 509150., 513425., 517700.,
      524675., 529150., 533625., 538100., 544475., 549150., 553825., 558500.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      339360., 443240., 481960., 520680.,  304856.,  669400.,  842550.,
      882950., 923350., 527770., 1005400., 1246550., 1286950., 1327350.,
      750970., 414280., 499730., 514370.,  529010.,  281502.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {620350.,  660750.,  701150.,
                                         1024350., 1064750., 1105150.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      674336.,  678720.,  880520.,  886480.,  957320.,  963920.,  1034120.,
      1041360., 605176.,  609712.,  1328520., 1338800., 1671650., 1685100.,
      1751650., 1765900., 1831650., 1846700., 1046270., 1055540., 1994120.,
      2010800., 2471650., 2493100., 2551650., 2573900., 2631650., 2654700.,
      1487870., 1501940., 816632.,  828560.,  984190.,  999460.,  1012990.,
      1028740., 1041790., 1058020., 553122.,  563004.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1231650., 1240700., 1311650., 1321500., 1391650., 1402300.,
      2031650., 2048700., 2111650., 2129500., 2191650., 2210300.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x8x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1344288., 1348672., 1353056., 1357440., 1755080., 1761040., 1767000.,
      1772960., 1908040., 1914640., 1921240., 1927840., 2061000., 2068240.,
      2075480., 2082720., 1205816., 1210352., 1214888., 1219424., 2646760.,
      2657040., 2667320., 2677600., 3329850., 3343300., 3356750., 3370200.,
      3489050., 3503300., 3517550., 3531800., 3648250., 3663300., 3678350.,
      3693400., 2083270., 2092540., 2101810., 2111080., 3971560., 3988240.,
      4004920., 4021600., 4921850., 4943300., 4964750., 4986200., 5081050.,
      5103300., 5125550., 5147800., 5240250., 5263300., 5286350., 5309400.,
      2961670., 2975740., 2989810., 3003880., 1621336., 1633264., 1645192.,
      1657120., 1953110., 1968380., 1983650., 1998920., 2010230., 2025980.,
      2041730., 2057480., 2067350., 2083580., 2099810., 2116040., 1096362.,
      1106244., 1116126., 1126008.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x8x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2454250., 2463300., 2472350., 2481400., 2613450., 2623300.,
      2633150., 2643000., 2772650., 2783300., 2793950., 2804600.,
      4046250., 4063300., 4080350., 4097400., 4205450., 4223300.,
      4241150., 4259000., 4364650., 4383300., 4401950., 4420600.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3008.,  5100.,  5720.,  3404.,  5890.,
                                         9600.,  10250., 5920.,  8830.,  14150.,
                                         14800., 8440.,  11770., 18700., 19350.,
                                         10960., 4914.,  7460.,  7700.,  4122.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7325.,  7975.,  11875.,
                                         12525., 16425., 17075.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5866.,  6016.,  9930.,  10200., 11130., 11440., 6610.,  6808.,
      11435., 11780., 18600., 19200., 19850., 20500., 11435., 11840.,
      17105., 17660., 27350., 28300., 28600., 29600., 16265., 16880.,
      22775., 23540., 36100., 37400., 37350., 38700., 21095., 21920.,
      9306.,  9828.,  14035., 14920., 14485., 15400., 7686.,  8244.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {14225., 14650., 15475., 15950.,
                                         22975., 23750., 24225., 25050.,
                                         31725., 32850., 32975., 34150.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11582., 11732., 11882., 12032., 19590., 19860., 20130., 20400., 21950.,
      22260., 22570., 22880., 13022., 13220., 13418., 13616., 22525., 22870.,
      23215., 23560., 36600., 37200., 37800., 38400., 39050., 39700., 40350.,
      41000., 22465., 22870., 23275., 23680., 33655., 34210., 34765., 35320.,
      53750., 54700., 55650., 56600., 56200., 57200., 58200., 59200., 31915.,
      32530., 33145., 33760., 44785., 45550., 46315., 47080., 70900., 72200.,
      73500., 74800., 73350., 74700., 76050., 77400., 41365., 42190., 43015.,
      43840., 18090., 18612., 19134., 19656., 27185., 28070., 28955., 29840.,
      28055., 28970., 29885., 30800., 14814., 15372., 15930., 16488.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28025., 28450., 28875., 29300., 30475., 30950., 31425., 31900.,
      45175., 45950., 46725., 47500., 47625., 48450., 49275., 50100.,
      62325., 63450., 64575., 65700., 64775., 65950., 67125., 68300.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23380.,  39660., 44540.,  26500.,  46025., 74975., 80075.,
      46205.,  69125., 110675., 115775., 65945., 92225., 146375.,
      151475., 85685., 38115.,  57685.,  59545., 31743.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57125., 62225.,  92825.,
                                         97925., 128525., 133625.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46172.,  46760.,  78260.,  79320.,  87860.,  89080.,  52220.,  53000.,
      90685.,  92050.,  147575., 149950., 157575., 160150., 90805.,  92410.,
      136045., 138250., 217575., 221350., 227575., 231550., 129445., 131890.,
      181405., 184450., 287575., 292750., 297575., 302950., 168085., 171370.,
      74151.,  76230.,  111845., 115370., 115445., 119090., 61263.,  63486.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {112575., 114250., 122575., 124450.,
                                         182575., 185650., 192575., 195850.,
                                         252575., 257050., 262575., 267250.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      91756.,  92344.,  92932.,  93520.,  155460., 156520., 157580., 158640.,
      174500., 175720., 176940., 178160., 103660., 104440., 105220., 106000.,
      180005., 181370., 182735., 184100., 292775., 295150., 297525., 299900.,
      312575., 315150., 317725., 320300., 180005., 181610., 183215., 184820.,
      269885., 272090., 274295., 276500., 431375., 435150., 438925., 442700.,
      451175., 455150., 459125., 463100., 256445., 258890., 261335., 263780.,
      359765., 362810., 365855., 368900., 569975., 575150., 580325., 585500.,
      589775., 595150., 600525., 605900., 332885., 336170., 339455., 342740.,
      146223., 148302., 150381., 152460., 220165., 223690., 227215., 230740.,
      227245., 230890., 234535., 238180., 120303., 122526., 124749., 126972.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      223475., 225150., 226825., 228500., 243275., 245150., 247025., 248900.,
      362075., 365150., 368225., 371300., 381875., 385150., 388425., 391700.,
      500675., 505150., 509625., 514100., 520475., 525150., 529825., 534500.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184328.,  312760., 351480., 209096., 363850., 592550., 632950.,
      365050.,  546970., 875350., 915750., 521290., 730090., 1158150.,
      1198550., 677530., 300150., 453530., 468170., 249030.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {451150., 491550.,  733950.,
                                         774350., 1016750., 1057150.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      366328.,  368656.,  621320.,  625520.,  698120.,  702960.,  415096.,
      418192.,  722270.,  727700.,  1175650., 1185100., 1255650., 1265900.,
      723710.,  730100.,  1085150., 1093940., 1735650., 1750700., 1815650.,
      1831500., 1032830., 1042580., 1448030., 1460180., 2295650., 2316300.,
      2375650., 2397100., 1341950., 1355060., 592002.,  600300.,  892990.,
      907060.,  921790.,  936340.,  489186.,  498060.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      895650.,  902300.,  975650.,  983100.,  1455650., 1467900.,
      1535650., 1548700., 2015650., 2033500., 2095650., 2114300.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      730328.,  732656.,  734984.,  737312.,  1238440., 1242640., 1246840.,
      1251040., 1391400., 1396240., 1401080., 1405920., 827096.,  830192.,
      833288.,  836384.,  1439110., 1444540., 1449970., 1455400., 2341850.,
      2351300., 2360750., 2370200., 2501050., 2511300., 2521550., 2531800.,
      1441030., 1447420., 1453810., 1460200., 2161510., 2170300., 2179090.,
      2187880., 3456250., 3471300., 3486350., 3501400., 3615450., 3631300.,
      3647150., 3663000., 2055910., 2065660., 2075410., 2085160., 2883910.,
      2896060., 2908210., 2920360., 4570650., 4591300., 4611950., 4632600.,
      4729850., 4751300., 4772750., 4794200., 2670790., 2683900., 2697010.,
      2710120., 1175706., 1184004., 1192302., 1200600., 1771910., 1785980.,
      1800050., 1814120., 1829030., 1843580., 1858130., 1872680., 969498.,
      978372.,  987246.,  996120.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1784650., 1791300., 1797950., 1804600., 1943850., 1951300.,
      1958750., 1966200., 2899050., 2911300., 2923550., 2935800.,
      3058250., 3071300., 3084350., 3097400., 4013450., 4031300.,
      4049150., 4067000., 4172650., 4191300., 4209950., 4228600.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4532.,  6000.,  6620.,  3914.,  8780.,
                                         11150., 11800., 6790.,  13100., 16350.,
                                         17000., 9670.,  17420., 21550., 22200.,
                                         12550., 7118.,  8590.,  8830.,  4719.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8225.,  8875.,  13425.,
                                         14075., 18625., 19275.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8832.,  9064.,  11680., 12000., 12880., 13240., 7600.,  7828.,
      17030., 17560., 21600., 22300., 22850., 23600., 13115., 13580.,
      25350., 26200., 31600., 32700., 32850., 34000., 18635., 19340.,
      33670., 34840., 41600., 43100., 42850., 44400., 24155., 25100.,
      13438., 14236., 16160., 17180., 16610., 17660., 8799.,  9438.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15975., 16450., 17225., 17750.,
                                         25975., 26850., 27225., 28150.,
                                         35975., 37250., 37225., 38550.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17432., 17664., 17896., 18128., 23040., 23360., 23680., 24000., 25400.,
      25760., 26120., 26480., 14972., 15200., 15428., 15656., 33530., 34060.,
      34590., 35120., 42500., 43200., 43900., 44600., 44950., 45700., 46450.,
      47200., 25765., 26230., 26695., 27160., 49850., 50700., 51550., 52400.,
      62100., 63200., 64300., 65400., 64550., 65700., 66850., 68000., 36565.,
      37270., 37975., 38680., 66170., 67340., 68510., 69680., 81700., 83200.,
      84700., 86200., 84150., 85700., 87250., 88800., 47365., 48310., 49255.,
      50200., 26078., 26876., 27674., 28472., 31300., 32320., 33340., 34360.,
      32170., 33220., 34270., 35320., 16959., 17598., 18237., 18876.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31475., 31950., 32425., 32900., 33925., 34450., 34975., 35500.,
      51075., 51950., 52825., 53700., 53525., 54450., 55375., 56300.,
      70675., 71950., 73225., 74500., 73125., 74450., 75775., 77100.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35296.,  46760.,  51640.,  30520.,  68660., 87175.,  92275.,
      53045.,  102580., 127975., 133075., 75605., 136500., 168775.,
      173875., 98165.,  55156.,  66455.,  68315., 36357.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {64225.,  69325.,  105025.,
                                         110125., 145825., 150925.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69680.,  70592.,  92260.,  93520.,  101860., 103280., 60140.,  61040.,
      135220., 137320., 171575., 174350., 181575., 184550., 104245., 106090.,
      201780., 205160., 251575., 255950., 261575., 266150., 148405., 151210.,
      268340., 273000., 331575., 337550., 341575., 347750., 192565., 196330.,
      107132., 110312., 128845., 132910., 132445., 136630., 70167.,  72714.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {126575., 128450., 136575., 138650.,
                                         206575., 210050., 216575., 220250.,
                                         286575., 291650., 296575., 301850.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      138448., 139360., 140272., 141184., 183260., 184520., 185780., 187040.,
      202300., 203720., 205140., 206560., 119380., 120280., 121180., 122080.,
      268340., 270440., 272540., 274640., 340375., 343150., 345925., 348700.,
      360175., 363150., 366125., 369100., 206645., 208490., 210335., 212180.,
      400180., 403560., 406940., 410320., 498775., 503150., 507525., 511900.,
      518575., 523150., 527725., 532300., 294005., 296810., 299615., 302420.,
      532020., 536680., 541340., 546000., 657175., 663150., 669125., 675100.,
      676975., 683150., 689325., 695500., 381365., 385130., 388895., 392660.,
      211084., 214264., 217444., 220624., 253625., 257690., 261755., 265820.,
      260705., 264890., 269075., 273260., 137787., 140334., 142881., 145428.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      251275., 253150., 255025., 256900., 271075., 273150., 275225., 277300.,
      409675., 413150., 416625., 420100., 429475., 433150., 436825., 440500.,
      568075., 573150., 578225., 583300., 587875., 593150., 598425., 603700.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      278560.,  369160., 407880.,  241016.,  543000., 689350.,  729750.,
      419290.,  811800., 1012550., 1052950., 597850., 1080600., 1335750.,
      1376150., 776410., 434120.,  522610.,  537250., 285294.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {507550., 547950.,  830750.,
                                         871150., 1153950., 1194350.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      553504.,  557120.,  733320.,  738320.,  810120.,  815760.,  478456.,
      482032.,  1077640., 1086000., 1367650., 1378700., 1447650., 1459500.,
      831230.,  838580.,  1610120., 1623600., 2007650., 2025100., 2087650.,
      2105900., 1184510., 1195700., 2142600., 2161200., 2647650., 2671500.,
      2727650., 2752300., 1537790., 1552820., 855544.,  868240.,  1028990.,
      1045220., 1057790., 1074500., 560418.,  570588.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1007650., 1015100., 1087650., 1095900., 1647650., 1661500.,
      1727650., 1742300., 2287650., 2307900., 2367650., 2388700.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1103392., 1107008., 1110624., 1114240., 1461640., 1466640., 1471640.,
      1476640., 1614600., 1620240., 1625880., 1631520., 953336.,  956912.,
      960488.,  964064.,  2146920., 2155280., 2163640., 2172000., 2724250.,
      2735300., 2746350., 2757400., 2883450., 2895300., 2907150., 2919000.,
      1655110., 1662460., 1669810., 1677160., 3206760., 3220240., 3233720.,
      3247200., 3997850., 4015300., 4032750., 4050200., 4157050., 4175300.,
      4193550., 4211800., 2357830., 2369020., 2380210., 2391400., 4266600.,
      4285200., 4303800., 4322400., 5271450., 5295300., 5319150., 5343000.,
      5430650., 5455300., 5479950., 5504600., 3060550., 3075580., 3090610.,
      3105640., 1698392., 1711088., 1723784., 1736480., 2041750., 2057980.,
      2074210., 2090440., 2098870., 2115580., 2132290., 2149000., 1110666.,
      1120836., 1131006., 1141176.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2007850., 2015300., 2022750., 2030200., 2167050., 2175300.,
      2183550., 2191800., 3281450., 3295300., 3309150., 3323000.,
      3440650., 3455300., 3469950., 3484600., 4555050., 4575300.,
      4595550., 4615800., 4714250., 4735300., 4756350., 4777400.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5500.,  7180.,  7800.,  8420.,  4934.,  10800., 13600., 14250., 14900.,
      8530.,  16200., 20100., 20750., 21400., 12130., 21600., 26600., 27250.,
      27900., 15730., 8830.,  10610., 10850., 11090., 5913.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10025., 10675., 11325., 16525., 17175.,
                                         17825., 23025., 23675., 24325.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10720., 11000., 13980., 14360., 15180., 15600., 16380., 16840., 9580.,
      9868.,  20950., 21600., 26350., 27200., 27600., 28500., 28850., 29800.,
      16475., 17060., 31350., 32400., 38850., 40200., 40100., 41500., 41350.,
      42800., 23375., 24260., 41750., 43200., 51350., 53200., 52600., 54500.,
      53850., 55800., 30275., 31460., 16670., 17660., 19960., 21220., 20410.,
      21700., 20860., 22180., 11025., 11826.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19475., 20050., 20725., 21350., 21975., 22650., 31975., 33050., 33225.,
      34350., 34475., 35650., 44475., 46050., 45725., 47350., 46975., 48650.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21160.,  21440.,  21720.,  22000.,  27580.,  27960.,  28340.,  28720.,
      29940.,  30360.,  30780.,  31200.,  32300.,  32760.,  33220.,  33680.,
      18872.,  19160.,  19448.,  19736.,  41250.,  41900.,  42550.,  43200.,
      51850.,  52700.,  53550.,  54400.,  54300.,  55200.,  56100.,  57000.,
      56750.,  57700.,  58650.,  59600.,  32365.,  32950.,  33535.,  34120.,
      61650.,  62700.,  63750.,  64800.,  76350.,  77700.,  79050.,  80400.,
      78800.,  80200.,  81600.,  83000.,  81250.,  82700.,  84150.,  85600.,
      45865.,  46750.,  47635.,  48520.,  82050.,  83500.,  84950.,  86400.,
      100850., 102700., 104550., 106400., 103300., 105200., 107100., 109000.,
      105750., 107700., 109650., 111600., 59365.,  60550.,  61735.,  62920.,
      32350.,  33340.,  34330.,  35320.,  38660.,  39920.,  41180.,  42440.,
      39530.,  40820.,  42110.,  43400.,  40400.,  41720.,  43040.,  44360.,
      21249.,  22050.,  22851.,  23652.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38375., 38950., 39525., 40100., 40825., 41450., 42075., 42700., 43275.,
      43950., 44625., 45300., 62875., 63950., 65025., 66100., 65325., 66450.,
      67575., 68700., 67775., 68950., 70125., 71300., 87375., 88950., 90525.,
      92100., 89825., 91450., 93075., 94700., 92275., 93950., 95625., 97300.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42944.,  56080.,  60960.,  65840.,  38560.,  84580.,  106475.,
      111575., 116675., 66725.,  126980., 157475., 162575., 167675.,
      94925.,  169380., 208475., 213575., 218675., 123125., 68468.,
      82135.,  83995.,  85855.,  45585.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {78425.,  83525.,  88625.,
                                         129425., 134525., 139625.,
                                         180425., 185525., 190625.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84784.,  85888.,  110660., 112160., 120260., 121920., 129860., 131680.,
      75980.,  77120.,  166580., 169160., 209575., 212950., 219575., 223150.,
      229575., 233350., 131125., 133450., 249780., 253960., 309575., 314950.,
      319575., 325150., 329575., 335350., 186325., 189850., 332980., 338760.,
      409575., 416950., 419575., 427150., 429575., 437350., 241525., 246250.,
      132988., 136936., 159245., 164270., 162845., 167990., 166445., 171710.,
      87975.,  91170.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      154575., 156850., 164575., 167050., 174575., 177250.,
      254575., 258850., 264575., 269050., 274575., 279250.,
      354575., 360850., 364575., 371050., 374575., 381250.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      168464., 169568., 170672., 171776., 219820., 221320., 222820., 224320.,
      238860., 240520., 242180., 243840., 257900., 259720., 261540., 263360.,
      150820., 151960., 153100., 154240., 330580., 333160., 335740., 338320.,
      415775., 419150., 422525., 425900., 435575., 439150., 442725., 446300.,
      455375., 459150., 462925., 466700., 259925., 262250., 264575., 266900.,
      495380., 499560., 503740., 507920., 613775., 619150., 624525., 629900.,
      633575., 639150., 644725., 650300., 653375., 659150., 664925., 670700.,
      369125., 372650., 376175., 379700., 660180., 665960., 671740., 677520.,
      811775., 819150., 826525., 833900., 831575., 839150., 846725., 854300.,
      851375., 859150., 866925., 874700., 478325., 483050., 487775., 492500.,
      262028., 265976., 269924., 273872., 313465., 318490., 323515., 328540.,
      320545., 325690., 330835., 335980., 327625., 332890., 338155., 343420.,
      172755., 175950., 179145., 182340.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      306875., 309150., 311425., 313700., 326675., 329150., 331625., 334100.,
      346475., 349150., 351825., 354500., 504875., 509150., 513425., 517700.,
      524675., 529150., 533625., 538100., 544475., 549150., 553825., 558500.,
      702875., 709150., 715425., 721700., 722675., 729150., 735625., 742100.,
      742475., 749150., 755825., 762500.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      339360., 443240.,  481960.,  520680.,  304856.,  669400.,  842550.,
      882950., 923350.,  527770.,  1005400., 1246550., 1286950., 1327350.,
      750970., 1341400., 1650550., 1690950., 1731350., 974170.,  539080.,
      646130., 660770.,  675410.,  357822.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {620350.,  660750.,  701150.,
                                         1024350., 1064750., 1105150.,
                                         1428350., 1468750., 1509150.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      674336.,  678720.,  880520.,  886480.,  957320.,  963920.,  1034120.,
      1041360., 605176.,  609712.,  1328520., 1338800., 1671650., 1685100.,
      1751650., 1765900., 1831650., 1846700., 1046270., 1055540., 1994120.,
      2010800., 2471650., 2493100., 2551650., 2573900., 2631650., 2654700.,
      1487870., 1501940., 2659720., 2682800., 3271650., 3301100., 3351650.,
      3381900., 3431650., 3462700., 1929470., 1948340., 1062392., 1078160.,
      1272190., 1292260., 1300990., 1321540., 1329790., 1350820., 702882.,
      715644.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1231650., 1240700., 1311650., 1321500., 1391650., 1402300.,
      2031650., 2048700., 2111650., 2129500., 2191650., 2210300.,
      2831650., 2856700., 2911650., 2937500., 2991650., 3018300.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME1x10x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1344288., 1348672., 1353056., 1357440., 1755080., 1761040., 1767000.,
      1772960., 1908040., 1914640., 1921240., 1927840., 2061000., 2068240.,
      2075480., 2082720., 1205816., 1210352., 1214888., 1219424., 2646760.,
      2657040., 2667320., 2677600., 3329850., 3343300., 3356750., 3370200.,
      3489050., 3503300., 3517550., 3531800., 3648250., 3663300., 3678350.,
      3693400., 2083270., 2092540., 2101810., 2111080., 3971560., 3988240.,
      4004920., 4021600., 4921850., 4943300., 4964750., 4986200., 5081050.,
      5103300., 5125550., 5147800., 5240250., 5263300., 5286350., 5309400.,
      2961670., 2975740., 2989810., 3003880., 5296360., 5319440., 5342520.,
      5365600., 6513850., 6543300., 6572750., 6602200., 6673050., 6703300.,
      6733550., 6763800., 6832250., 6863300., 6894350., 6925400., 3840070.,
      3858940., 3877810., 3896680., 2109016., 2124784., 2140552., 2156320.,
      2524310., 2544380., 2564450., 2584520., 2581430., 2601980., 2622530.,
      2643080., 2638550., 2659580., 2680610., 2701640., 1393002., 1405764.,
      1418526., 1431288.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID1x10x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2454250., 2463300., 2472350., 2481400., 2613450., 2623300.,
      2633150., 2643000., 2772650., 2783300., 2793950., 2804600.,
      4046250., 4063300., 4080350., 4097400., 4205450., 4223300.,
      4241150., 4259000., 4364650., 4383300., 4401950., 4420600.,
      5638250., 5663300., 5688350., 5713400., 5797450., 5823300.,
      5849150., 5875000., 5956650., 5983300., 6009950., 6036600.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1755.,  3080.,  3620.,  2205.,  4420.,  7325.,  7975.,  4660.,
      7360.,  11875., 12525., 7180.,  3213.,  4940.,  5180.,  2799.,
      10134., 16310., 16850., 9702.,  14710., 23250., 23900., 13480.,
      17650., 27800., 28450., 16000., 7182.,  10820., 11060., 5886.,
      18513., 29540., 30080., 17199., 25000., 39175., 39825., 22300.,
      27940., 43725., 44375., 24820., 11151., 16700., 16940., 8973.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7325.,  7975.,  11875., 12525.,
                                         23250., 23900., 27800., 28450.,
                                         39175., 39825., 43725., 44375.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3429.,  3510.,  6010.,  6160.,  7060.,  7240.,  4293.,  4410.,  8600.,
      8840.,  14225., 14650., 15475., 15950., 9020.,  9320.,  14270., 14720.,
      22975., 23750., 24225., 25050., 13850., 14360., 6093.,  6426.,  9310.,
      9880.,  9760.,  10360., 5229.,  5598.,  19746., 20268., 31735., 32620.,
      32785., 33700., 18846., 19404., 28445., 29420., 44850., 46500., 46100.,
      47800., 25925., 26960., 34115., 35300., 53600., 55600., 54850., 56900.,
      30755., 32000., 13590., 14364., 20335., 21640., 20785., 22120., 10962.,
      11772., 36063., 37026., 57460., 59080., 58510., 60160., 33399., 34398.,
      48290., 50000., 75475., 78350., 76725., 79650., 42830., 44600., 53960.,
      55880., 84225., 87450., 85475., 88750., 47660., 49640., 21087., 22302.,
      31360., 33400., 31810., 33880., 16695., 17946.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14225., 14650., 15475., 15950., 22975., 23750., 24225., 25050.,
      44850., 46500., 46100., 47800., 53600., 55600., 54850., 56900.,
      75475., 78350., 76725., 79650., 84225., 87450., 85475., 88750.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6777.,   6858.,   6939.,   7020.,   11870.,  12020.,  12170.,  12320.,
      13940.,  14120.,  14300.,  14480.,  8469.,   8586.,   8703.,   8820.,
      16960.,  17200.,  17440.,  17680.,  28025.,  28450.,  28875.,  29300.,
      30475.,  30950.,  31425.,  31900.,  17740.,  18040.,  18340.,  18640.,
      28090.,  28540.,  28990.,  29440.,  45175.,  45950.,  46725.,  47500.,
      47625.,  48450.,  49275.,  50100.,  27190.,  27700.,  28210.,  28720.,
      11853.,  12186.,  12519.,  12852.,  18050.,  18620.,  19190.,  19760.,
      18920.,  19520.,  20120.,  20720.,  10089.,  10458.,  10827.,  11196.,
      38970.,  39492.,  40014.,  40536.,  62585.,  63470.,  64355.,  65240.,
      64655.,  65570.,  66485.,  67400.,  37134.,  37692.,  38250.,  38808.,
      55915.,  56890.,  57865.,  58840.,  88050.,  89700.,  91350.,  93000.,
      90500.,  92200.,  93900.,  95600.,  50815.,  51850.,  52885.,  53920.,
      67045.,  68230.,  69415.,  70600.,  105200., 107200., 109200., 111200.,
      107650., 109700., 111750., 113800., 60265.,  61510.,  62755.,  64000.,
      26406.,  27180.,  27954.,  28728.,  39365.,  40670.,  41975.,  43280.,
      40235.,  41570.,  42905.,  44240.,  21114.,  21924.,  22734.,  23544.,
      71163.,  72126.,  73089.,  74052.,  113300., 114920., 116540., 118160.,
      115370., 117020., 118670., 120320., 65799.,  66798.,  67797.,  68796.,
      94870.,  96580.,  98290.,  100000., 148075., 150950., 153825., 156700.,
      150525., 153450., 156375., 159300., 83890.,  85660.,  87430.,  89200.,
      106000., 107920., 109840., 111760., 165225., 168450., 171675., 174900.,
      167675., 170950., 174225., 177500., 93340.,  95320.,  97300.,  99280.,
      40959.,  42174.,  43389.,  44604.,  60680.,  62720.,  64760.,  66800.,
      61550.,  63620.,  65690.,  67760.,  32139.,  33390.,  34641.,  35892.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28025.,  28450.,  28875.,  29300.,  30475.,  30950.,  31425.,  31900.,
      45175.,  45950.,  46725.,  47500.,  47625.,  48450.,  49275.,  50100.,
      88050.,  89700.,  91350.,  93000.,  90500.,  92200.,  93900.,  95600.,
      105200., 107200., 109200., 111200., 107650., 109700., 111750., 113800.,
      148075., 150950., 153825., 156700., 150525., 153450., 156375., 159300.,
      165225., 168450., 171675., 174900., 167675., 170950., 174225., 177500.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13545.,  23815.,  28075.,  17109.,  34475.,  57125.,  62225.,  36335.,
      57575.,  92825.,  97925.,  56075.,  24885.,  38155.,  40015.,  21537.,
      79695.,  128185., 132445., 76203.,  115325., 182075., 187175., 105425.,
      138425., 217775., 222875., 125165., 55755.,  83725.,  85585.,  45351.,
      145845., 232555., 236815., 135297., 196175., 307025., 312125., 174515.,
      219275., 342725., 347825., 194255., 86625.,  129295., 131155., 69165.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57125.,  62225.,  92825.,  97925.,
                                         182075., 187175., 217775., 222875.,
                                         307025., 312125., 342725., 347825.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26775.,  27090.,  47045.,  47630.,  55445.,  56150.,  33759.,  34218.,
      68005.,  68950.,  112575., 114250., 122575., 124450., 71485.,  72670.,
      113365., 115150., 182575., 185650., 192575., 195850., 110125., 112150.,
      48447.,  49770.,  74045.,  76310.,  77645.,  80030.,  41607.,  43074.,
      157311., 159390., 252845., 256370., 261245., 264890., 150183., 152406.,
      226765., 230650., 357575., 364150., 367575., 374350., 206725., 210850.,
      272125., 276850., 427575., 435550., 437575., 445750., 245365., 250330.,
      108423., 111510., 162245., 167450., 165845., 171170., 87471.,  90702.,
      287847., 291690., 458645., 465110., 467045., 473630., 266607., 270594.,
      385525., 392350., 602575., 614050., 612575., 624250., 341965., 349030.,
      430885., 438550., 672575., 685450., 682575., 695650., 380605., 388510.,
      168399., 173250., 250445., 258590., 254045., 262310., 133335., 138330.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      112575., 114250., 122575., 124450., 182575., 185650., 192575., 195850.,
      357575., 364150., 367575., 374350., 427575., 435550., 437575., 445750.,
      602575., 614050., 612575., 624250., 672575., 685450., 682575., 695650.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      53235.,   53550.,   53865.,   54180.,   93505.,   94090.,   94675.,
      95260.,   110185.,  110890.,  111595.,  112300.,  67059.,   67518.,
      67977.,   68436.,   135065.,  136010.,  136955.,  137900.,  223475.,
      225150.,  226825.,  228500.,  243275.,  245150.,  247025.,  248900.,
      141785.,  142970.,  144155.,  145340.,  224945.,  226730.,  228515.,
      230300.,  362075.,  365150.,  368225.,  371300.,  381875.,  385150.,
      388425.,  391700.,  218225.,  220250.,  222275.,  224300.,  95571.,
      96894.,   98217.,   99540.,   145825.,  148090.,  150355.,  152620.,
      152905.,  155290.,  157675.,  160060.,  81747.,   83214.,   84681.,
      86148.,   312543.,  314622.,  316701.,  318780.,  502165.,  505690.,
      509215.,  512740.,  518845.,  522490.,  526135.,  529780.,  298143.,
      300366.,  302589.,  304812.,  449645.,  453530.,  457415.,  461300.,
      708575.,  715150.,  721725.,  728300.,  728375.,  735150.,  741925.,
      748700.,  409325.,  413450.,  417575.,  421700.,  539525.,  544250.,
      548975.,  553700.,  847175.,  855150.,  863125.,  871100.,  866975.,
      875150.,  883325.,  891500.,  485765.,  490730.,  495695.,  500660.,
      213759.,  216846.,  219933.,  223020.,  319285.,  324490.,  329695.,
      334900.,  326365.,  331690.,  337015.,  342340.,  171711.,  174942.,
      178173.,  181404.,  571851.,  575694.,  579537.,  583380.,  910825.,
      917290.,  923755.,  930220.,  927505.,  934090.,  940675.,  947260.,
      529227.,  533214.,  537201.,  541188.,  764225.,  771050.,  777875.,
      784700.,  1193675., 1205150., 1216625., 1228100., 1213475., 1225150.,
      1236825., 1248500., 676865.,  683930.,  690995.,  698060.,  854105.,
      861770.,  869435.,  877100.,  1332275., 1345150., 1358025., 1370900.,
      1352075., 1365150., 1378225., 1391300., 753305.,  761210.,  769115.,
      777020.,  331947.,  336798.,  341649.,  346500.,  492745.,  500890.,
      509035.,  517180.,  499825.,  508090.,  516355.,  524620.,  261675.,
      266670.,  271665.,  276660.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      223475.,  225150.,  226825.,  228500.,  243275.,  245150.,  247025.,
      248900.,  362075.,  365150.,  368225.,  371300.,  381875.,  385150.,
      388425.,  391700.,  708575.,  715150.,  721725.,  728300.,  728375.,
      735150.,  741925.,  748700.,  847175.,  855150.,  863125.,  871100.,
      866975.,  875150.,  883325.,  891500.,  1193675., 1205150., 1216625.,
      1228100., 1213475., 1225150., 1236825., 1248500., 1332275., 1345150.,
      1358025., 1370900., 1352075., 1365150., 1378225., 1391300.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      106398.,  187250.,  221090.,  134766.,  272290.,  451150.,  491550.,
      286930.,  455410.,  733950.,  774350.,  443170.,  195822.,  299810.,
      314450.,  168894.,  632070.,  1016330., 1050170., 603990.,  913210.,
      1440950., 1481350., 833770.,  1096330., 1723750., 1764150., 990010.,
      439254.,  658490.,  673130.,  355878.,  1157742., 1845410., 1879250.,
      1073214., 1554130., 2430750., 2471150., 1380610., 1737250., 2713550.,
      2753950., 1536850., 682686.,  1017170., 1031810., 542862.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      451150.,  491550.,  733950.,  774350.,  1440950., 1481350.,
      1723750., 1764150., 2430750., 2471150., 2713550., 2753950.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      211554.,  212796.,  372190.,  374500.,  439390.,  442180.,  267714.,
      269532.,  540830.,  544580.,  895650.,  902300.,  975650.,  983100.,
      569150.,  573860.,  903710.,  910820.,  1455650., 1467900., 1535650.,
      1548700., 878270.,  886340.,  386370.,  391644.,  590590.,  599620.,
      619390.,  628900.,  331938.,  337788.,  1255842., 1264140., 2018590.,
      2032660., 2085790., 2100340., 1199106., 1207980., 1810910., 1826420.,
      2855650., 2881900., 2935650., 2962700., 1651070., 1667540., 2173790.,
      2192660., 3415650., 3447500., 3495650., 3528300., 1960190., 1980020.,
      866178.,  878508.,  1296190., 1316980., 1324990., 1346260., 698850.,
      711756.,  2300130., 2315484., 3664990., 3690820., 3732190., 3758500.,
      2130498., 2146428., 3080990., 3108260., 4815650., 4861500., 4895650.,
      4942300., 2732990., 2761220., 3443870., 3474500., 5375650., 5427100.,
      5455650., 5507900., 3042110., 3073700., 1345986., 1365372., 2001790.,
      2034340., 2030590., 2063620., 1065762., 1085724.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      895650.,  902300.,  975650.,  983100.,  1455650., 1467900.,
      1535650., 1548700., 2855650., 2881900., 2935650., 2962700.,
      3415650., 3447500., 3495650., 3528300., 4815650., 4861500.,
      4895650., 4942300., 5375650., 5427100., 5455650., 5507900.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      421866.,   423108.,   424350.,   425592.,   742070.,   744380.,
      746690.,   749000.,   875990.,   878780.,   881570.,   884360.,
      533610.,   535428.,   537246.,   539064.,   1077910.,  1081660.,
      1085410.,  1089160.,  1784650.,  1791300.,  1797950.,  1804600.,
      1943850.,  1951300.,  1958750.,  1966200.,  1133590.,  1138300.,
      1143010.,  1147720.,  1800310.,  1807420.,  1814530.,  1821640.,
      2899050.,  2911300.,  2923550.,  2935800.,  3058250.,  3071300.,
      3084350.,  3097400.,  1748470.,  1756540.,  1764610.,  1772680.,
      767466.,   772740.,   778014.,   783288.,   1172150.,  1181180.,
      1190210.,  1199240.,  1229270.,  1238780.,  1248290.,  1257800.,
      658026.,   663876.,   669726.,   675576.,   2503386.,  2511684.,
      2519982.,  2528280.,  4023110.,  4037180.,  4051250.,  4065320.,
      4157030.,  4171580.,  4186130.,  4200680.,  2389338.,  2398212.,
      2407086.,  2415960.,  3606310.,  3621820.,  3637330.,  3652840.,
      5685050.,  5711300.,  5737550.,  5763800.,  5844250.,  5871300.,
      5898350.,  5925400.,  3285670.,  3302140.,  3318610.,  3335080.,
      4328710.,  4347580.,  4366450.,  4385320.,  6799450.,  6831300.,
      6863150.,  6895000.,  6958650.,  6991300.,  7023950.,  7056600.,
      3900550.,  3920380.,  3940210.,  3960040.,  1720026.,  1732356.,
      1744686.,  1757016.,  2571590.,  2592380.,  2613170.,  2633960.,
      2628710.,  2649980.,  2671250.,  2692520.,  1384794.,  1397700.,
      1410606.,  1423512.,  4584906.,  4600260.,  4615614.,  4630968.,
      7304150.,  7329980.,  7355810.,  7381640.,  7438070.,  7464380.,
      7490690.,  7517000.,  4245066.,  4260996.,  4276926.,  4292856.,
      6134710.,  6161980.,  6189250.,  6216520.,  9585450.,  9631300.,
      9677150.,  9723000.,  9744650.,  9791300.,  9837950.,  9884600.,
      5437750.,  5465980.,  5494210.,  5522440.,  6857110.,  6887740.,
      6918370.,  6949000.,  10699850., 10751300., 10802750., 10854200.,
      10859050., 10911300., 10963550., 11015800., 6052630.,  6084220.,
      6115810.,  6147400.,  2672586.,  2691972.,  2711358.,  2730744.,
      3971030.,  4003580.,  4036130.,  4068680.,  4028150.,  4061180.,
      4094210.,  4127240.,  2111562.,  2131524.,  2151486.,  2171448.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1784650.,  1791300.,  1797950.,  1804600.,  1943850.,  1951300.,
      1958750.,  1966200.,  2899050.,  2911300.,  2923550.,  2935800.,
      3058250.,  3071300.,  3084350.,  3097400.,  5685050.,  5711300.,
      5737550.,  5763800.,  5844250.,  5871300.,  5898350.,  5925400.,
      6799450.,  6831300.,  6863150.,  6895000.,  6958650.,  6991300.,
      7023950.,  7056600.,  9585450.,  9631300.,  9677150.,  9723000.,
      9744650.,  9791300.,  9837950.,  9884600.,  10699850., 10751300.,
      10802750., 10854200., 10859050., 10911300., 10963550., 11015800.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2666.,  3670.,  4210.,  2541.,  6620.,  8550.,  9200.,  5350.,
      10940., 13750., 14400., 8230.,  4670.,  5710.,  5950.,  3207.,
      15098., 18790., 19330., 11109., 21740., 26750., 27400., 15430.,
      26060., 31950., 32600., 18310., 10382., 12430., 12670., 6735.,
      27530., 33910., 34450., 19677., 36860., 44950., 45600., 25510.,
      41180., 50150., 50800., 28390., 16094., 19150., 19390., 10263.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8225.,  8875.,  13425., 14075.,
                                         26425., 27075., 31625., 32275.,
                                         44625., 45275., 49825., 50475.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5206.,  5332.,  7160.,   7340.,  8210.,   8420.,  4947.,  5082.,  12870.,
      13240., 16600., 17100.,  17850., 18400.,  10355., 10700., 21190., 21880.,
      26600., 27500., 27850.,  28800., 15875.,  16460., 8830.,  9340.,  10760.,
      11420., 11210., 11900.,  5991.,  6414.,   29398., 30196., 36560., 37580.,
      37610., 38660., 21579.,  22218., 41990.,  43480., 51600., 53500., 52850.,
      54800., 29675., 30860.,  50310., 52120.,  61600., 63900., 62850., 65200.,
      35195., 36620., 19582.,  20764., 23360.,  24860., 23810., 25340., 12543.,
      13470., 53590., 55060.,  65960., 67820.,  67010., 68900., 38211., 39354.,
      71110., 73720., 86600.,  89900., 87850.,  91200., 48995., 51020., 79430.,
      82360., 96600., 100300., 97850., 101600., 54515., 56780., 30334., 32188.,
      35960., 38300., 36410.,  38780., 19095.,  20526.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15975., 16450., 17225., 17750., 25975., 26850., 27225., 28150.,
      50975., 52850., 52225., 54150., 60975., 63250., 62225., 64550.,
      85975., 89250., 87225., 90550., 95975., 99650., 97225., 100950.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10286.,  10412.,  10538.,  10664.,  14140.,  14320.,  14500.,  14680.,
      16210.,  16420.,  16630.,  16840.,  9759.,   9894.,   10029.,  10164.,
      25370.,  25740.,  26110.,  26480.,  32700.,  33200.,  33700.,  34200.,
      35150.,  35700.,  36250.,  36800.,  20365.,  20710.,  21055.,  21400.,
      41690.,  42380.,  43070.,  43760.,  52300.,  53200.,  54100.,  55000.,
      54750.,  55700.,  56650.,  57600.,  31165.,  31750.,  32335.,  32920.,
      17150.,  17660.,  18170.,  18680.,  20860.,  21520.,  22180.,  22840.,
      21730.,  22420.,  23110.,  23800.,  11559.,  11982.,  12405.,  12828.,
      57998.,  58796.,  59594.,  60392.,  72100.,  73120.,  74140.,  75160.,
      74170.,  75220.,  76270.,  77320.,  42519.,  43158.,  43797.,  44436.,
      82490.,  83980.,  85470.,  86960.,  101300., 103200., 105100., 107000.,
      103750., 105700., 107650., 109600., 58165.,  59350.,  60535.,  61720.,
      98810.,  100620., 102430., 104240., 120900., 123200., 125500., 127800.,
      123350., 125700., 128050., 130400., 68965.,  70390.,  71815.,  73240.,
      37982.,  39164.,  40346.,  41528.,  45220.,  46720.,  48220.,  49720.,
      46090.,  47620.,  49150.,  50680.,  24159.,  25086.,  26013.,  26940.,
      105710., 107180., 108650., 110120., 130060., 131920., 133780., 135640.,
      132130., 134020., 135910., 137800., 75279.,  76422.,  77565.,  78708.,
      139610., 142220., 144830., 147440., 169900., 173200., 176500., 179800.,
      172350., 175700., 179050., 182400., 95965.,  97990.,  100015., 102040.,
      155930., 158860., 161790., 164720., 189500., 193200., 196900., 200600.,
      191950., 195700., 199450., 203200., 106765., 109030., 111295., 113560.,
      58814.,  60668.,  62522.,  64376.,  69580.,  71920.,  74260.,  76600.,
      70450.,  72820.,  75190.,  77560.,  36759.,  38190.,  39621.,  41052.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31475.,  31950.,  32425.,  32900.,  33925.,  34450.,  34975.,  35500.,
      51075.,  51950.,  52825.,  53700.,  53525.,  54450.,  55375.,  56300.,
      100075., 101950., 103825., 105700., 102525., 104450., 106375., 108300.,
      119675., 121950., 124225., 126500., 122125., 124450., 126775., 129100.,
      168675., 171950., 175225., 178500., 171125., 174450., 177775., 181100.,
      188275., 191950., 195625., 199300., 190725., 194450., 198175., 201900.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20644.,  28475.,  32735.,  19761.,  51700.,  66775.,  71875.,  41765.,
      85620.,  107575., 112675., 64325.,  36148.,  44135.,  45995.,  24693.,
      118756., 147755., 152015., 87297.,  170420., 209575., 214675., 120725.,
      204340., 250375., 255475., 143285., 80500.,  96215.,  98075.,  51909.,
      216868., 267035., 271295., 154833., 289140., 352375., 357475., 199685.,
      323060., 393175., 398275., 222245., 124852., 148295., 150155., 79125.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {64225.,  69325.,  105025., 110125.,
                                         207025., 212125., 247825., 252925.,
                                         349825., 354925., 390625., 395725.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      40796.,  41288.,  56245.,  56950.,  64645.,  65470.,  38991.,  39522.,
      101940., 103400., 131575., 133550., 141575., 143750., 82165.,  83530.,
      168500., 171240., 211575., 215150., 221575., 225350., 126325., 128650.,
      70268.,  72296.,  85645.,  88270.,  89245.,  91990.,  47703.,  49386.,
      234332., 237512., 291445., 295510., 299845., 304030., 172047., 174594.,
      334900., 340840., 411575., 419150., 421575., 429350., 236725., 241450.,
      401460., 408680., 491575., 500750., 501575., 510950., 280885., 286570.,
      156284., 161000., 186445., 192430., 190045., 196150., 100119., 103818.,
      427868., 433736., 526645., 534070., 535045., 542590., 305103., 309666.,
      567860., 578280., 691575., 704750., 701575., 714950., 391285., 399370.,
      634420., 646120., 771575., 786350., 781575., 796550., 435445., 444490.,
      242300., 249704., 287245., 296590., 290845., 300310., 152535., 158250.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      126575., 128450., 136575., 138650., 206575., 210050., 216575., 220250.,
      406575., 414050., 416575., 424250., 486575., 495650., 496575., 505850.,
      686575., 699650., 696575., 709850., 766575., 781250., 776575., 791450.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      81100.,   81592.,   82084.,   82576.,   111785.,  112490.,  113195.,
      113900.,  128465.,  129290.,  130115.,  130940.,  77451.,   77982.,
      78513.,   79044.,   202420.,  203880.,  205340.,  206800.,  261175.,
      263150.,  265125.,  267100.,  280975.,  283150.,  285325.,  287500.,
      162965.,  164330.,  165695.,  167060.,  334260.,  337000.,  339740.,
      342480.,  419575.,  423150.,  426725.,  430300.,  439375.,  443150.,
      446925.,  450700.,  250325.,  252650.,  254975.,  257300.,  138508.,
      140536.,  142564.,  144592.,  168665.,  171290.,  173915.,  176540.,
      175745.,  178490.,  181235.,  183980.,  93723.,   95406.,   97089.,
      98772.,   465484.,  468664.,  471844.,  475024.,  578825.,  582890.,
      586955.,  591020.,  595505.,  599690.,  603875.,  608060.,  341547.,
      344094.,  346641.,  349188.,  663860.,  669800.,  675740.,  681680.,
      815575.,  823150.,  830725.,  838300.,  835375.,  843150.,  850925.,
      858700.,  468725.,  473450.,  478175.,  482900.,  795700.,  802920.,
      810140.,  817360.,  973975.,  983150.,  992325.,  1001500., 993775.,
      1003150., 1012525., 1021900., 556085.,  561770.,  567455.,  573140.,
      307852.,  312568.,  317284.,  322000.,  366905.,  372890.,  378875.,
      384860.,  373985.,  380090.,  386195.,  392300.,  196539.,  200238.,
      203937.,  207636.,  849868.,  855736.,  861604.,  867472.,  1045865.,
      1053290., 1060715., 1068140., 1062545., 1070090., 1077635., 1085180.,
      605643.,  610206.,  614769.,  619332.,  1125300., 1135720., 1146140.,
      1156560., 1369975., 1383150., 1396325., 1409500., 1389775., 1403150.,
      1416525., 1429900., 774485.,  782570.,  790655.,  798740.,  1257140.,
      1268840., 1280540., 1292240., 1528375., 1543150., 1557925., 1572700.,
      1548175., 1563150., 1578125., 1593100., 861845.,  870890.,  879935.,
      888980.,  477196.,  484600.,  492004.,  499408.,  565145.,  574490.,
      583835.,  593180.,  572225.,  581690.,  591155.,  600620.,  299355.,
      305070.,  310785.,  316500.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      251275.,  253150.,  255025.,  256900.,  271075.,  273150.,  275225.,
      277300.,  409675.,  413150.,  416625.,  420100.,  429475.,  433150.,
      436825.,  440500.,  805675.,  813150.,  820625.,  828100.,  825475.,
      833150.,  840825.,  848500.,  964075.,  973150.,  982225.,  991300.,
      983875.,  993150.,  1002425., 1011700., 1360075., 1373150., 1386225.,
      1399300., 1379875., 1393150., 1406425., 1419700., 1518475., 1533150.,
      1547825., 1562500., 1538275., 1553150., 1568025., 1582900.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      162440.,  224290.,  258130.,  155838.,  408600.,  527750.,  568150.,
      330010.,  677400.,  850950.,  891350.,  508570.,  284360.,  346930.,
      361570.,  193710.,  941960.,  1171810., 1205650., 692094.,  1349400.,
      1658950., 1699350., 954970.,  1618200., 1982150., 2022550., 1133530.,
      633800.,  756850.,  771490.,  407406.,  1721480., 2119330., 2153170.,
      1228350., 2290200., 2790150., 2830550., 1579930., 2559000., 3113350.,
      3153750., 1758490., 983240.,  1166770., 1181410., 621102.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      507550.,  547950.,  830750.,  871150.,  1638750., 1679150.,
      1961950., 2002350., 2769950., 2810350., 3093150., 3133550.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      322936.,  324880.,  445790.,  448580.,  512990.,  516260.,  309570.,
      311676.,  811400.,  817200.,  1047650., 1055500., 1127650., 1136300.,
      654590.,  660020.,  1343880., 1354800., 1687650., 1701900., 1767650.,
      1782700., 1007870., 1017140., 560632.,  568720.,  683390.,  693860.,
      712190.,  723140.,  380706.,  387420.,  1871224., 1883920., 2327390.,
      2343620., 2394590., 2411300., 1374018., 1384188., 2675080., 2698800.,
      3287650., 3317900., 3367650., 3398700., 1891070., 1909940., 3207560.,
      3236400., 3927650., 3964300., 4007650., 4045100., 2244350., 2267060.,
      1248760., 1267600., 1489790., 1513700., 1518590., 1542980., 800034.,
      814812.,  3419512., 3442960., 4208990., 4238660., 4276190., 4306340.,
      2438466., 2456700., 4538760., 4580400., 5527650., 5580300., 5607650.,
      5661100., 3127550., 3159860., 5071240., 5118000., 6167650., 6226700.,
      6247650., 6307500., 3480830., 3516980., 1936888., 1966480., 2296190.,
      2333540., 2324990., 2362820., 1219362., 1242204.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1007650., 1015100., 1087650., 1095900., 1647650., 1661500.,
      1727650., 1742300., 3247650., 3277500., 3327650., 3358300.,
      3887650., 3923900., 3967650., 4004700., 5487650., 5539900.,
      5567650., 5620700., 6127650., 6186300., 6207650., 6267100.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      643928.,   645872.,   647816.,   649760.,   888790.,   891580.,
      894370.,   897160.,   1022710.,  1025980.,  1029250.,  1032520.,
      617034.,   619140.,   621246.,   623352.,   1617000.,  1622800.,
      1628600.,  1634400.,  2087450.,  2095300.,  2103150.,  2111000.,
      2246650.,  2255300.,  2263950.,  2272600.,  1303750.,  1309180.,
      1314610.,  1320040.,  2676840.,  2687760.,  2698680.,  2709600.,
      3361050.,  3375300.,  3389550.,  3403800.,  3520250.,  3535300.,
      3550350.,  3565400.,  2006470.,  2015740.,  2025010.,  2034280.,
      1113176.,  1121264.,  1129352.,  1137440.,  1356310.,  1366780.,
      1377250.,  1387720.,  1413430.,  1424380.,  1435330.,  1446280.,
      754698.,   761412.,   768126.,   774840.,   3729752.,  3742448.,
      3755144.,  3767840.,  4638550.,  4654780.,  4671010.,  4687240.,
      4772470.,  4789180.,  4805890.,  4822600.,  2737866.,  2748036.,
      2758206.,  2768376.,  5326440.,  5350160.,  5373880.,  5397600.,
      6545050.,  6575300.,  6605550.,  6635800.,  6704250.,  6735300.,
      6766350.,  6797400.,  3763270.,  3782140.,  3801010.,  3819880.,
      6386280.,  6415120.,  6443960.,  6472800.,  7818650.,  7855300.,
      7891950.,  7928600.,  7977850.,  8015300.,  8052750.,  8090200.,
      4465990.,  4488700.,  4511410.,  4534120.,  2478680.,  2497520.,
      2516360.,  2535200.,  2955670.,  2979580.,  3003490.,  3027400.,
      3012790.,  3037180.,  3061570.,  3085960.,  1585290.,  1600068.,
      1614846.,  1629624.,  6815576.,  6839024.,  6862472.,  6885920.,
      8388310.,  8417980.,  8447650.,  8477320.,  8522230.,  8552380.,
      8582530.,  8612680.,  4858698.,  4876932.,  4895166.,  4913400.,
      9035880.,  9077520.,  9119160.,  9160800.,  11002650., 11055300.,
      11107950., 11160600., 11161850., 11215300., 11268750., 11322200.,
      6222790.,  6255100.,  6287410.,  6319720.,  10095720., 10142480.,
      10189240., 10236000., 12276250., 12335300., 12394350., 12453400.,
      12435450., 12495300., 12555150., 12615000., 6925510.,  6961660.,
      6997810.,  7033960.,  3844184.,  3873776.,  3903368.,  3932960.,
      4555030.,  4592380.,  4629730.,  4667080.,  4612150.,  4649980.,
      4687810.,  4725640.,  2415882.,  2438724.,  2461566.,  2484408.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2007850.,  2015300.,  2022750.,  2030200.,  2167050.,  2175300.,
      2183550.,  2191800.,  3281450.,  3295300.,  3309150.,  3323000.,
      3440650.,  3455300.,  3469950.,  3484600.,  6465450.,  6495300.,
      6525150.,  6555000.,  6624650.,  6655300.,  6685950.,  6716600.,
      7739050.,  7775300.,  7811550.,  7847800.,  7898250.,  7935300.,
      7972350.,  8009400.,  10923050., 10975300., 11027550., 11079800.,
      11082250., 11135300., 11188350., 11241400., 12196650., 12255300.,
      12313950., 12372600., 12355850., 12415300., 12474750., 12534200.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3190.,  4310.,  4850.,  5390.,  3213.,  8100.,  10350., 11000., 11650.,
      6730.,  13500., 16850., 17500., 18150., 10330., 5770.,  7010.,  7250.,
      7490.,  4023.,  18730., 23210., 23750., 24290., 13923., 27000., 33100.,
      33750., 34400., 19330., 32400., 39600., 40250., 40900., 22930., 12910.,
      15410., 15650., 15890., 8433.,  34270., 42110., 42650., 43190., 24633.,
      45900., 55850., 56500., 57150., 31930., 51300., 62350., 63000., 63650.,
      35530., 20050., 23810., 24050., 24290., 12843.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10025., 10675., 11325., 16525., 17175., 17825., 32775., 33425., 34075.,
      39275., 39925., 40575., 55525., 56175., 56825., 62025., 62675., 63325.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6230.,   6380.,   8410.,   8620.,   9460.,   9700.,   10510.,  10780.,
      6255.,   6426.,   15750.,  16200.,  20100.,  20700.,  21350.,  22000.,
      22600.,  23300.,  13025.,  13460.,  26150.,  27000.,  32600.,  33700.,
      33850.,  35000.,  35100.,  36300.,  19925.,  20660.,  10910.,  11540.,
      13210.,  14020.,  13660.,  14500.,  14110.,  14980.,  7515.,   8046.,
      36470.,  37460.,  45160.,  46420.,  46210.,  47500.,  47260.,  48580.,
      27045.,  27846.,  52150.,  54000.,  63850.,  66200.,  65100.,  67500.,
      66350.,  68800.,  37175.,  38660.,  62550.,  64800.,  76350.,  79200.,
      77600.,  80500.,  78850.,  81800.,  44075.,  45860.,  24350.,  25820.,
      28960.,  30820.,  29410.,  31300.,  29860.,  31780.,  15705.,  16866.,
      66710.,  68540.,  81910.,  84220.,  82960.,  85300.,  84010.,  86380.,
      47835.,  49266.,  88550.,  91800.,  107600., 111700., 108850., 113000.,
      110100., 114300., 61325.,  63860.,  98950.,  102600., 120100., 124700.,
      121350., 126000., 122600., 127300., 68225.,  71060.,  37790.,  40100.,
      44710.,  47620.,  45160.,  48100.,  45610.,  48580.,  23895.,  25686.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19475.,  20050.,  20725.,  21350.,  21975.,  22650.,  31975.,  33050.,
      33225.,  34350.,  34475.,  35650.,  63225.,  65550.,  64475.,  66850.,
      65725.,  68150.,  75725.,  78550.,  76975.,  79850.,  78225.,  81150.,
      106975., 111050., 108225., 112350., 109475., 113650., 119475., 124050.,
      120725., 125350., 121975., 126650.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12310.,  12460.,  12610.,  12760.,  16610.,  16820.,  17030.,  17240.,
      18680.,  18920.,  19160.,  19400.,  20750.,  21020.,  21290.,  21560.,
      12339.,  12510.,  12681.,  12852.,  31050.,  31500.,  31950.,  32400.,
      39600.,  40200.,  40800.,  41400.,  42050.,  42700.,  43350.,  44000.,
      44500.,  45200.,  45900.,  46600.,  25615.,  26050.,  26485.,  26920.,
      51450.,  52300.,  53150.,  54000.,  64100.,  65200.,  66300.,  67400.,
      66550.,  67700.,  68850.,  70000.,  69000.,  70200.,  71400.,  72600.,
      39115.,  39850.,  40585.,  41320.,  21190.,  21820.,  22450.,  23080.,
      25610.,  26420.,  27230.,  28040.,  26480.,  27320.,  28160.,  29000.,
      27350.,  28220.,  29090.,  29960.,  14499.,  15030.,  15561.,  16092.,
      71950.,  72940.,  73930.,  74920.,  89060.,  90320.,  91580.,  92840.,
      91130.,  92420.,  93710.,  95000.,  93200.,  94520.,  95840.,  97160.,
      53289.,  54090.,  54891.,  55692.,  102450., 104300., 106150., 108000.,
      125350., 127700., 130050., 132400., 127800., 130200., 132600., 135000.,
      130250., 132700., 135150., 137600., 72865.,  74350.,  75835.,  77320.,
      122850., 125100., 127350., 129600., 149850., 152700., 155550., 158400.,
      152300., 155200., 158100., 161000., 154750., 157700., 160650., 163600.,
      86365.,  88150.,  89935.,  91720.,  47230.,  48700.,  50170.,  51640.,
      56060.,  57920.,  59780.,  61640.,  56930.,  58820.,  60710.,  62600.,
      57800.,  59720.,  61640.,  63560.,  30249.,  31410.,  32571.,  33732.,
      131590., 133420., 135250., 137080., 161510., 163820., 166130., 168440.,
      163580., 165920., 168260., 170600., 165650., 168020., 170390., 172760.,
      94239.,  95670.,  97101.,  98532.,  173850., 177100., 180350., 183600.,
      211100., 215200., 219300., 223400., 213550., 217700., 221850., 226000.,
      216000., 220200., 224400., 228600., 120115., 122650., 125185., 127720.,
      194250., 197900., 201550., 205200., 235600., 240200., 244800., 249400.,
      238050., 242700., 247350., 252000., 240500., 245200., 249900., 254600.,
      133615., 136450., 139285., 142120., 73270.,  75580.,  77890.,  80200.,
      86510.,  89420.,  92330.,  95240.,  87380.,  90320.,  93260.,  96200.,
      88250.,  91220.,  94190.,  97160.,  45999.,  47790.,  49581.,  51372.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38375.,  38950.,  39525.,  40100.,  40825.,  41450.,  42075.,  42700.,
      43275.,  43950.,  44625.,  45300.,  62875.,  63950.,  65025.,  66100.,
      65325.,  66450.,  67575.,  68700.,  67775.,  68950.,  70125.,  71300.,
      124125., 126450., 128775., 131100., 126575., 128950., 131325., 133700.,
      129025., 131450., 133875., 136300., 148625., 151450., 154275., 157100.,
      151075., 153950., 156825., 159700., 153525., 156450., 159375., 162300.,
      209875., 213950., 218025., 222100., 212325., 216450., 220575., 224700.,
      214775., 218950., 223125., 227300., 234375., 238950., 243525., 248100.,
      236825., 241450., 246075., 250700., 239275., 243950., 248625., 253300.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24788.,  33535.,  37795.,  42055.,  25065.,  63380.,  80975.,  86075.,
      91175.,  52625.,  105780., 131975., 137075., 142175., 80825.,  44708.,
      54235.,  56095.,  57955.,  31005.,  147428., 182635., 186895., 191155.,
      109485., 211780., 259475., 264575., 269675., 151325., 254180., 310475.,
      315575., 320675., 179525., 100148., 119335., 121195., 123055., 65025.,
      270068., 331735., 335995., 340255., 193905., 360180., 437975., 443075.,
      448175., 250025., 402580., 488975., 494075., 499175., 278225., 155588.,
      184435., 186295., 188155., 99045.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      78425.,  83525.,  88625.,  129425., 134525., 139625.,
      256925., 262025., 267125., 307925., 313025., 318125.,
      435425., 440525., 445625., 486425., 491525., 496625.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48988.,  49576.,  66245.,  67070.,  74645.,  75590.,  83045.,  84110.,
      49455.,  50130.,  124980., 126760., 159575., 161950., 169575., 172150.,
      179575., 182350., 103525., 105250., 208180., 211560., 259575., 263950.,
      269575., 274150., 279575., 284350., 158725., 161650., 86908.,  89416.,
      105245., 108470., 108845., 112190., 112445., 115910., 59895.,  62010.,
      290908., 294856., 360245., 365270., 368645., 373790., 377045., 382310.,
      215775., 218970., 416180., 423560., 509575., 518950., 519575., 529150.,
      529575., 539350., 296725., 302650., 499380., 508360., 609575., 620950.,
      619575., 631150., 629575., 641350., 351925., 359050., 194428., 200296.,
      231245., 238670., 234845., 242390., 238445., 246110., 125415., 130050.,
      532828., 540136., 654245., 663470., 662645., 671990., 671045., 680510.,
      382095., 387810., 707380., 720360., 859575., 875950., 869575., 886150.,
      879575., 896350., 489925., 500050., 790580., 805160., 959575., 977950.,
      969575., 988150., 979575., 998350., 545125., 556450., 301948., 311176.,
      357245., 368870., 360845., 372590., 364445., 376310., 190935., 198090.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      154575., 156850., 164575., 167050., 174575., 177250., 254575., 258850.,
      264575., 269050., 274575., 279250., 504575., 513850., 514575., 524050.,
      524575., 534250., 604575., 615850., 614575., 626050., 624575., 636250.,
      854575., 870850., 864575., 881050., 874575., 891250., 954575., 972850.,
      964575., 983050., 974575., 993250.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97388.,   97976.,   98564.,   99152.,   131665.,  132490.,  133315.,
      134140.,  148345.,  149290.,  150235.,  151180.,  165025.,  166090.,
      167155.,  168220.,  98235.,   98910.,   99585.,   100260.,  248180.,
      249960.,  251740.,  253520.,  316775.,  319150.,  321525.,  323900.,
      336575.,  339150.,  341725.,  344300.,  356375.,  359150.,  361925.,
      364700.,  205325.,  207050.,  208775.,  210500.,  412980.,  416360.,
      419740.,  423120.,  514775.,  519150.,  523525.,  527900.,  534575.,
      539150.,  543725.,  548300.,  554375.,  559150.,  563925.,  568700.,
      314525.,  317450.,  320375.,  323300.,  171308.,  173816.,  176324.,
      178832.,  207265.,  210490.,  213715.,  216940.,  214345.,  217690.,
      221035.,  224380.,  221425.,  224890.,  228355.,  231820.,  117675.,
      119790.,  121905.,  124020.,  577868.,  581816.,  585764.,  589712.,
      715465.,  720490.,  725515.,  730540.,  732145.,  737290.,  742435.,
      747580.,  748825.,  754090.,  759355.,  764620.,  428355.,  431550.,
      434745.,  437940.,  824980.,  832360.,  839740.,  847120.,  1009775.,
      1019150., 1028525., 1037900., 1029575., 1039150., 1048725., 1058300.,
      1049375., 1059150., 1068925., 1078700., 587525.,  593450.,  599375.,
      605300.,  989780.,  998760.,  1007740., 1016720., 1207775., 1219150.,
      1230525., 1241900., 1227575., 1239150., 1250725., 1262300., 1247375.,
      1259150., 1270925., 1282700., 696725.,  703850.,  710975.,  718100.,
      382988.,  388856.,  394724.,  400592.,  455065.,  462490.,  469915.,
      477340.,  462145.,  469690.,  477235.,  484780.,  469225.,  476890.,
      484555.,  492220.,  246195.,  250830.,  255465.,  260100.,  1058348.,
      1065656., 1072964., 1080272., 1299265., 1308490., 1317715., 1326940.,
      1315945., 1325290., 1334635., 1343980., 1332625., 1342090., 1351555.,
      1361020., 758475.,  764190.,  769905.,  775620.,  1401780., 1414760.,
      1427740., 1440720., 1702775., 1719150., 1735525., 1751900., 1722575.,
      1739150., 1755725., 1772300., 1742375., 1759150., 1775925., 1792700.,
      969725.,  979850.,  989975.,  1000100., 1566580., 1581160., 1595740.,
      1610320., 1900775., 1919150., 1937525., 1955900., 1920575., 1939150.,
      1957725., 1976300., 1940375., 1959150., 1977925., 1996700., 1078925.,
      1090250., 1101575., 1112900., 594668.,  603896.,  613124.,  622352.,
      702865.,  714490.,  726115.,  737740.,  709945.,  721690.,  733435.,
      745180.,  717025.,  728890.,  740755.,  752620.,  374715.,  381870.,
      389025.,  396180.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      306875.,  309150.,  311425.,  313700.,  326675.,  329150.,  331625.,
      334100.,  346475.,  349150.,  351825.,  354500.,  504875.,  509150.,
      513425.,  517700.,  524675.,  529150.,  533625.,  538100.,  544475.,
      549150.,  553825.,  558500.,  999875.,  1009150., 1018425., 1027700.,
      1019675., 1029150., 1038625., 1048100., 1039475., 1049150., 1058825.,
      1068500., 1197875., 1209150., 1220425., 1231700., 1217675., 1229150.,
      1240625., 1252100., 1237475., 1249150., 1260825., 1272500., 1692875.,
      1709150., 1725425., 1741700., 1712675., 1729150., 1745625., 1762100.,
      1732475., 1749150., 1765825., 1782500., 1890875., 1909150., 1927425.,
      1945700., 1910675., 1929150., 1947625., 1966100., 1930475., 1949150.,
      1967825., 1986500.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      195400.,  264530.,  298370.,  332210.,  197982.,  501400.,  640550.,
      680950.,  721350.,  416170.,  837400.,  1044550., 1084950., 1125350.,
      639370.,  351880.,  426530.,  441170.,  455810.,  243342.,  1169800.,
      1448930., 1482770., 1516610., 868302.,  1677400., 2054550., 2094950.,
      2135350., 1197370., 2013400., 2458550., 2498950., 2539350., 1420570.,
      788680.,  938930.,  953570.,  968210.,  510462.,  2144200., 2633330.,
      2667170., 2701010., 1538622., 2853400., 3468550., 3508950., 3549350.,
      1978570., 3189400., 3872550., 3912950., 3953350., 2201770., 1225480.,
      1451330., 1465970., 1480610., 777582.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      620350.,  660750.,  701150.,  1024350., 1064750., 1105150.,
      2034350., 2074750., 2115150., 2438350., 2478750., 2519150.,
      3448350., 3488750., 3529150., 3852350., 3892750., 3933150.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      388472.,  390800.,  525790.,  529060.,  592990.,  596740.,  660190.,
      664420.,  393282.,  395964.,  995720.,  1002800., 1271650., 1281100.,
      1351650., 1361900., 1431650., 1442700., 825470.,  832340.,  1661320.,
      1674800., 2071650., 2089100., 2151650., 2169900., 2231650., 2250700.,
      1267070., 1278740., 693752.,  703760.,  840190.,  853060.,  868990.,
      882340.,  897790.,  911620.,  478242.,  486684.,  2323832., 2339600.,
      2877790., 2897860., 2944990., 2965540., 3012190., 3033220., 1723842.,
      1736604., 3325320., 3354800., 4071650., 4109100., 4151650., 4189900.,
      4231650., 4270700., 2371070., 2394740., 3990920., 4026800., 4871650.,
      4917100., 4951650., 4997900., 5031650., 5078700., 2812670., 2841140.,
      1553912., 1577360., 1848190., 1877860., 1876990., 1907140., 1905790.,
      1936420., 1002402., 1020924., 4259192., 4288400., 5229790., 5266660.,
      5296990., 5334340., 5364190., 5402020., 3054402., 3077244., 5654920.,
      5706800., 6871650., 6937100., 6951650., 7017900., 7031650., 7098700.,
      3916670., 3957140., 6320520., 6378800., 7671650., 7745100., 7751650.,
      7825900., 7831650., 7906700., 4358270., 4403540., 2414072., 2450960.,
      2856190., 2902660., 2884990., 2931940., 2913790., 2961220., 1526562.,
      1555164.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1231650., 1240700., 1311650., 1321500., 1391650., 1402300.,
      2031650., 2048700., 2111650., 2129500., 2191650., 2210300.,
      4031650., 4068700., 4111650., 4149500., 4191650., 4230300.,
      4831650., 4876700., 4911650., 4957500., 4991650., 5038300.,
      6831650., 6896700., 6911650., 6977500., 6991650., 7058300.,
      7631650., 7704700., 7711650., 7785500., 7791650., 7866300.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x7x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      774616.,   776944.,   779272.,   781600.,   1048310.,  1051580.,
      1054850.,  1058120.,  1182230.,  1185980.,  1189730.,  1193480.,
      1316150.,  1320380.,  1324610.,  1328840.,  783882.,   786564.,
      789246.,   791928.,   1984360.,  1991440.,  1998520.,  2005600.,
      2533850.,  2543300.,  2552750.,  2562200.,  2693050.,  2703300.,
      2713550.,  2723800.,  2852250.,  2863300.,  2874350.,  2885400.,
      1644070.,  1650940.,  1657810.,  1664680.,  3309160.,  3322640.,
      3336120.,  3349600.,  4125850.,  4143300.,  4160750.,  4178200.,
      4285050.,  4303300.,  4321550.,  4339800.,  4444250.,  4463300.,
      4482350.,  4501400.,  2522470.,  2534140.,  2545810.,  2557480.,
      1377496.,  1387504.,  1397512.,  1407520.,  1667510.,  1680380.,
      1693250.,  1706120.,  1724630.,  1737980.,  1751330.,  1764680.,
      1781750.,  1795580.,  1809410.,  1823240.,  948042.,   956484.,
      964926.,   973368.,   4631896.,  4647664.,  4663432.,  4679200.,
      5735510.,  5755580.,  5775650.,  5795720.,  5869430.,  5889980.,
      5910530.,  5931080.,  6003350.,  6024380.,  6045410.,  6066440.,
      3434922.,  3447684.,  3460446.,  3473208.,  6621160.,  6650640.,
      6680120.,  6709600.,  8105850.,  8143300.,  8180750.,  8218200.,
      8265050.,  8303300.,  8341550.,  8379800.,  8424250.,  8463300.,
      8502350.,  8541400.,  4718470.,  4742140.,  4765810.,  4789480.,
      7945960.,  7981840.,  8017720.,  8053600.,  9697850.,  9743300.,
      9788750.,  9834200.,  9857050.,  9903300.,  9949550.,  9995800.,
      10016250., 10063300., 10110350., 10157400., 5596870.,  5625340.,
      5653810.,  5682280.,  3084376.,  3107824.,  3131272.,  3154720.,
      3666710.,  3696380.,  3726050.,  3755720.,  3723830.,  3753980.,
      3784130.,  3814280.,  3780950.,  3811580.,  3842210.,  3872840.,
      1986282.,  2004804.,  2023326.,  2041848.,  8489176.,  8518384.,
      8547592.,  8576800.,  10422710., 10459580., 10496450., 10533320.,
      10556630., 10593980., 10631330., 10668680., 10690550., 10728380.,
      10766210., 10804040., 6085962.,  6108804.,  6131646.,  6154488.,
      11257960., 11309840., 11361720., 11413600., 13677850., 13743300.,
      13808750., 13874200., 13837050., 13903300., 13969550., 14035800.,
      13996250., 14063300., 14130350., 14197400., 7792870.,  7833340.,
      7873810.,  7914280.,  12582760., 12641040., 12699320., 12757600.,
      15269850., 15343300., 15416750., 15490200., 15429050., 15503300.,
      15577550., 15651800., 15588250., 15663300., 15738350., 15813400.,
      8671270.,  8716540.,  8761810.,  8807080.,  4791256.,  4828144.,
      4865032.,  4901920.,  5665910.,  5712380.,  5758850.,  5805320.,
      5723030.,  5769980.,  5816930.,  5863880.,  5780150.,  5827580.,
      5875010.,  5922440.,  3024522.,  3053124.,  3081726.,  3110328.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x7x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2454250.,  2463300.,  2472350.,  2481400.,  2613450.,  2623300.,
      2633150.,  2643000.,  2772650.,  2783300.,  2793950.,  2804600.,
      4046250.,  4063300.,  4080350.,  4097400.,  4205450.,  4223300.,
      4241150.,  4259000.,  4364650.,  4383300.,  4401950.,  4420600.,
      8026250.,  8063300.,  8100350.,  8137400.,  8185450.,  8223300.,
      8261150.,  8299000.,  8344650.,  8383300.,  8421950.,  8460600.,
      9618250.,  9663300.,  9708350.,  9753400.,  9777450.,  9823300.,
      9869150.,  9915000.,  9936650.,  9983300.,  10029950., 10076600.,
      13598250., 13663300., 13728350., 13793400., 13757450., 13823300.,
      13889150., 13955000., 13916650., 13983300., 14049950., 14116600.,
      15190250., 15263300., 15336350., 15409400., 15349450., 15423300.,
      15497150., 15571000., 15508650., 15583300., 15657950., 15732600.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3008.,  5100.,  5720.,  3404.,  5890.,  9600.,  10250., 5920.,
      8830.,  14150., 14800., 8440.,  3780.,  5780.,  6020.,  3240.,
      14096., 22460., 23080., 13148., 17650., 27800., 28450., 16000.,
      20590., 32350., 33000., 18520., 8316.,  12500., 12740., 6768.,
      25184., 39820., 40440., 22892., 29410., 46000., 46650., 26080.,
      32350., 50550., 51200., 28600., 12852., 19220., 19460., 10296.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7325.,  7975.,  11875., 12525.,
                                         25525., 26175., 30075., 30725.,
                                         43725., 44375., 48275., 48925.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5866.,  6016.,  9930.,   10200., 11130.,  11440., 6610.,  6808.,  11435.,
      11780., 18600., 19200.,  19850., 20500.,  11435., 11840., 17105., 17660.,
      27350., 28300., 28600.,  29600., 16265.,  16880., 7164.,  7560.,  10885.,
      11560., 11335., 12040.,  6048.,  6480.,   27370., 28192., 43530., 44920.,
      44730., 46160., 25426.,  26296., 34115.,  35300., 53600., 55600., 54850.,
      56900., 30755., 32000.,  39785., 41180.,  62350., 64700., 63600., 66000.,
      35585., 37040., 15732.,  16632., 23485.,  25000., 23935., 25480., 12600.,
      13536., 48874., 50368.,  77130., 79640.,  78330., 80880., 44242., 45784.,
      56795., 58820., 88600.,  92000., 89850.,  93300., 50075., 52160., 62465.,
      64700., 97350., 101100., 98600., 102400., 54905., 57200., 24300., 25704.,
      36085., 38440., 36535.,  38920., 19152.,  20592.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14225., 14650., 15475., 15950., 22975., 23750., 24225., 25050.,
      49225., 51050., 50475., 52350., 57975., 60150., 59225., 61450.,
      84225., 87450., 85475., 88750., 92975., 96550., 94225., 97850.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11582.,  11732.,  11882.,  12032.,  19590.,  19860.,  20130.,  20400.,
      21950.,  22260.,  22570.,  22880.,  13022.,  13220.,  13418.,  13616.,
      22525.,  22870.,  23215.,  23560.,  36600.,  37200.,  37800.,  38400.,
      39050.,  39700.,  40350.,  41000.,  22465.,  22870.,  23275.,  23680.,
      33655.,  34210.,  34765.,  35320.,  53750.,  54700.,  55650.,  56600.,
      56200.,  57200.,  58200.,  59200.,  31915.,  32530.,  33145.,  33760.,
      13932.,  14328.,  14724.,  15120.,  21095.,  21770.,  22445.,  23120.,
      21965.,  22670.,  23375.,  24080.,  11664.,  12096.,  12528.,  12960.,
      53918.,  54740.,  55562.,  56384.,  85670.,  87060.,  88450.,  89840.,
      88030.,  89460.,  90890.,  92320.,  49982.,  50852.,  51722.,  52592.,
      67045.,  68230.,  69415.,  70600.,  105200., 107200., 109200., 111200.,
      107650., 109700., 111750., 113800., 60265.,  61510.,  62755.,  64000.,
      78175.,  79570.,  80965.,  82360.,  122350., 124700., 127050., 129400.,
      124800., 127200., 129600., 132000., 69715.,  71170.,  72625.,  74080.,
      30564.,  31464.,  32364.,  33264.,  45455.,  46970.,  48485.,  50000.,
      46325.,  47870.,  49415.,  50960.,  24264.,  25200.,  26136.,  27072.,
      96254.,  97748.,  99242.,  100736., 151750., 154260., 156770., 159280.,
      154110., 156660., 159210., 161760., 86942.,  88484.,  90026.,  91568.,
      111565., 113590., 115615., 117640., 173800., 177200., 180600., 184000.,
      176250., 179700., 183150., 186600., 98065.,  100150., 102235., 104320.,
      122695., 124930., 127165., 129400., 190950., 194700., 198450., 202200.,
      193400., 197200., 201000., 204800., 107515., 109810., 112105., 114400.,
      47196.,  48600.,  50004.,  51408.,  69815.,  72170.,  74525.,  76880.,
      70685.,  73070.,  75455.,  77840.,  36864.,  38304.,  39744.,  41184.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28025.,  28450.,  28875.,  29300.,  30475.,  30950.,  31425.,  31900.,
      45175.,  45950.,  46725.,  47500.,  47625.,  48450.,  49275.,  50100.,
      96625.,  98450.,  100275., 102100., 99075.,  100950., 102825., 104700.,
      113775., 115950., 118125., 120300., 116225., 118450., 120675., 122900.,
      165225., 168450., 171675., 174900., 167675., 170950., 174225., 177500.,
      182375., 185950., 189525., 193100., 184825., 188450., 192075., 195700.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23380.,  39660.,  44540.,  26500.,  46025.,  74975.,  80075.,  46205.,
      69125.,  110675., 115775., 65945.,  29295.,  44665.,  46525.,  24939.,
      110740., 176300., 181180., 103108., 138425., 217775., 222875., 125165.,
      161525., 253475., 258575., 144905., 64575.,  96745.,  98605.,  52155.,
      198100., 312940., 317820., 179716., 230825., 360575., 365675., 204125.,
      253925., 396275., 401375., 223865., 99855.,  148825., 150685., 79371.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {57125.,  62225.,  92825.,  97925.,
                                         199925., 205025., 235625., 240725.,
                                         342725., 347825., 378425., 383525.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46172.,  46760.,  78260.,  79320.,  87860.,  89080.,  52220.,  53000.,
      90685.,  92050.,  147575., 149950., 157575., 160150., 90805.,  92410.,
      136045., 138250., 217575., 221350., 227575., 231550., 129445., 131890.,
      57015.,  58590.,  86645.,  89330.,  90245.,  93050.,  48159.,  49878.,
      218204., 221480., 347060., 352600., 356660., 362360., 202748., 206216.,
      272125., 276850., 427575., 435550., 437575., 445750., 245365., 250330.,
      317485., 323050., 497575., 506950., 507575., 517150., 284005., 289810.,
      125559., 129150., 187445., 193490., 191045., 197210., 100575., 104310.,
      390236., 396200., 615860., 625880., 625460., 635640., 353276., 359432.,
      453565., 461650., 707575., 721150., 717575., 731350., 399925., 408250.,
      498925., 507850., 777575., 792550., 787575., 802750., 438565., 447730.,
      194103., 199710., 288245., 297650., 291845., 301370., 152991., 158742.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      112575., 114250., 122575., 124450., 182575., 185650., 192575., 195850.,
      392575., 399850., 402575., 410050., 462575., 471250., 472575., 481450.,
      672575., 685450., 682575., 695650., 742575., 756850., 752575., 767050.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      91756.,   92344.,   92932.,   93520.,   155460.,  156520.,  157580.,
      158640.,  174500.,  175720.,  176940.,  178160.,  103660.,  104440.,
      105220.,  106000.,  180005.,  181370.,  182735.,  184100.,  292775.,
      295150.,  297525.,  299900.,  312575.,  315150.,  317725.,  320300.,
      180005.,  181610.,  183215.,  184820.,  269885.,  272090.,  274295.,
      276500.,  431375.,  435150.,  438925.,  442700.,  451175.,  455150.,
      459125.,  463100.,  256445.,  258890.,  261335.,  263780.,  112455.,
      114030.,  115605.,  117180.,  170605.,  173290.,  175975.,  178660.,
      177685.,  180490.,  183295.,  186100.,  94599.,   96318.,   98037.,
      99756.,   433132.,  436408.,  439684.,  442960.,  688580.,  694120.,
      699660.,  705200.,  707620.,  713320.,  719020.,  724720.,  402028.,
      405496.,  408964.,  412432.,  539525.,  544250.,  548975.,  553700.,
      847175.,  855150.,  863125.,  871100.,  866975.,  875150.,  883325.,
      891500.,  485765.,  490730.,  495695.,  500660.,  629405.,  634970.,
      640535.,  646100.,  985775.,  995150.,  1004525., 1013900., 1005575.,
      1015150., 1024725., 1034300., 562205.,  568010.,  573815.,  579620.,
      247527.,  251118.,  254709.,  258300.,  368845.,  374890.,  380935.,
      386980.,  375925.,  382090.,  388255.,  394420.,  197415.,  201150.,
      204885.,  208620.,  774508.,  780472.,  786436.,  792400.,  1221700.,
      1231720., 1241740., 1251760., 1240740., 1250920., 1261100., 1271280.,
      700396.,  706552.,  712708.,  718864.,  899045.,  907130.,  915215.,
      923300.,  1401575., 1415150., 1428725., 1442300., 1421375., 1435150.,
      1448925., 1462700., 791525.,  799850.,  808175.,  816500.,  988925.,
      997850.,  1006775., 1015700., 1540175., 1555150., 1570125., 1585100.,
      1559975., 1575150., 1590325., 1605500., 867965.,  877130.,  886295.,
      895460.,  382599.,  388206.,  393813.,  399420.,  567085.,  576490.,
      585895.,  595300.,  574165.,  583690.,  593215.,  602740.,  300231.,
      305982.,  311733.,  317484.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      223475.,  225150.,  226825.,  228500.,  243275.,  245150.,  247025.,
      248900.,  362075.,  365150.,  368225.,  371300.,  381875.,  385150.,
      388425.,  391700.,  777875.,  785150.,  792425.,  799700.,  797675.,
      805150.,  812625.,  820100.,  916475.,  925150.,  933825.,  942500.,
      936275.,  945150.,  954025.,  962900.,  1332275., 1345150., 1358025.,
      1370900., 1352075., 1365150., 1378225., 1391300., 1470875., 1485150.,
      1499425., 1513700., 1490675., 1505150., 1519625., 1534100.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184328.,  312760.,  351480.,  209096.,  363850.,  592550.,  632950.,
      365050.,  546970.,  875350.,  915750.,  521290.,  230598.,  351050.,
      365690.,  195606.,  877832.,  1396920., 1435640., 816584.,  1096330.,
      1723750., 1764150., 990010.,  1279450., 2006550., 2046950., 1146250.,
      508806.,  760970.,  775610.,  409302.,  1571336., 2481080., 2519800.,
      1424072., 1828810., 2854950., 2895350., 1614970., 2011930., 3137750.,
      3178150., 1771210., 787014.,  1170890., 1185530., 622998.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      451150.,  491550.,  733950.,  774350.,  1582350., 1622750.,
      1865150., 1905550., 2713550., 2753950., 2996350., 3036750.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      366328.,  368656.,  621320.,  625520.,  698120.,  702960.,  415096.,
      418192.,  722270.,  727700.,  1175650., 1185100., 1255650., 1265900.,
      723710.,  730100.,  1085150., 1093940., 1735650., 1750700., 1815650.,
      1831500., 1032830., 1042580., 454914.,  461196.,  691390.,  702100.,
      720190.,  731380.,  384354.,  391212.,  1742584., 1755664., 2771720.,
      2793840., 2848520., 2871280., 1619320., 1633168., 2173790., 2192660.,
      3415650., 3447500., 3495650., 3528300., 1960190., 1980020., 2536670.,
      2558900., 3975650., 4013100., 4055650., 4093900., 2269310., 2292500.,
      1003266., 1017612., 1497790., 1521940., 1526590., 1551220., 803682.,
      818604.,  3118840., 3142672., 4922120., 4962160., 4998920., 5039600.,
      2823544., 2848144., 3625310., 3657620., 5655650., 5709900., 5735650.,
      5790700., 3196670., 3229940., 3988190., 4023860., 6215650., 6275500.,
      6295650., 6356300., 3505790., 3542420., 1551618., 1574028., 2304190.,
      2341780., 2332990., 2371060., 1223010., 1245996.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      895650.,  902300.,  975650.,  983100.,  1455650., 1467900.,
      1535650., 1548700., 3135650., 3164700., 3215650., 3245500.,
      3695650., 3730300., 3775650., 3811100., 5375650., 5427100.,
      5455650., 5507900., 5935650., 5992700., 6015650., 6073500.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      730328.,   732656.,   734984.,   737312.,   1238440.,  1242640.,
      1246840.,  1251040.,  1391400.,  1396240.,  1401080.,  1405920.,
      827096.,   830192.,   833288.,   836384.,   1439110.,  1444540.,
      1449970.,  1455400.,  2341850.,  2351300.,  2360750.,  2370200.,
      2501050.,  2511300.,  2521550.,  2531800.,  1441030.,  1447420.,
      1453810.,  1460200.,  2161510.,  2170300.,  2179090.,  2187880.,
      3456250.,  3471300.,  3486350.,  3501400.,  3615450.,  3631300.,
      3647150.,  3663000.,  2055910.,  2065660.,  2075410.,  2085160.,
      903546.,   909828.,   916110.,   922392.,   1372070.,  1382780.,
      1393490.,  1404200.,  1429190.,  1440380.,  1451570.,  1462760.,
      761850.,   768708.,   775566.,   782424.,   3472088.,  3485168.,
      3498248.,  3511328.,  5521320.,  5543440.,  5565560.,  5587680.,
      5674280.,  5697040.,  5719800.,  5742560.,  3224792.,  3238640.,
      3252488.,  3266336.,  4328710.,  4347580.,  4366450.,  4385320.,
      6799450.,  6831300.,  6863150.,  6895000.,  6958650.,  6991300.,
      7023950.,  7056600.,  3900550.,  3920380.,  3940210.,  3960040.,
      5051110.,  5073340.,  5095570.,  5117800.,  7913850.,  7951300.,
      7988750.,  8026200.,  8073050.,  8111300.,  8149550.,  8187800.,
      4515430.,  4538620.,  4561810.,  4585000.,  1992186.,  2006532.,
      2020878.,  2035224.,  2971430.,  2995580.,  3019730.,  3043880.,
      3028550.,  3053180.,  3077810.,  3102440.,  1592442.,  1607364.,
      1622286.,  1637208.,  6213848.,  6237680.,  6261512.,  6285344.,
      9804200.,  9844240.,  9884280.,  9924320.,  9957160.,  9997840.,
      10038520., 10079200., 5622488.,  5647088.,  5671688.,  5696288.,
      7218310.,  7250620.,  7282930.,  7315240.,  11257050., 11311300.,
      11365550., 11419800., 11416250., 11471300., 11526350., 11581400.,
      6360070.,  6393340.,  6426610.,  6459880.,  7940710.,  7976380.,
      8012050.,  8047720.,  12371450., 12431300., 12491150., 12551000.,
      12530650., 12591300., 12651950., 12712600., 6974950.,  7011580.,
      7048210.,  7084840.,  3080826.,  3103236.,  3125646.,  3148056.,
      4570790.,  4608380.,  4645970.,  4683560.,  4627910.,  4665980.,
      4704050.,  4742120.,  2423034.,  2446020.,  2469006.,  2491992.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1784650.,  1791300.,  1797950.,  1804600.,  1943850.,  1951300.,
      1958750.,  1966200.,  2899050.,  2911300.,  2923550.,  2935800.,
      3058250.,  3071300.,  3084350.,  3097400.,  6242250.,  6271300.,
      6300350.,  6329400.,  6401450.,  6431300.,  6461150.,  6491000.,
      7356650.,  7391300.,  7425950.,  7460600.,  7515850.,  7551300.,
      7586750.,  7622200.,  10699850., 10751300., 10802750., 10854200.,
      10859050., 10911300., 10963550., 11015800., 11814250., 11871300.,
      11928350., 11985400., 11973450., 12031300., 12089150., 12147000.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4532.,  6000.,  6620.,  3914.,  8780.,  11150., 11800., 6790.,
      13100., 16350., 17000., 9670.,  5486.,  6670.,  6910.,  3711.,
      20916., 25840., 26460., 15050., 26060., 31950., 32600., 18310.,
      30380., 37150., 37800., 21190., 12014., 14350., 14590., 7743.,
      37300., 45680., 46300., 26186., 43340., 52750., 53400., 29830.,
      47660., 57950., 58600., 32710., 18542., 22030., 22270., 11775.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8225.,  8875.,  13425., 14075.,
                                         29025., 29675., 34225., 34875.,
                                         49825., 50475., 55025., 55675.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8832.,  9064.,  11680.,  12000.,  12880.,  13240.,  7600.,  7828.,
      17030., 17560., 21600.,  22300.,  22850.,  23600.,  13115., 13580.,
      25350., 26200., 31600.,  32700.,  32850.,  34000.,  18635., 19340.,
      10366., 10972., 12560.,  13340.,  13010.,  13820.,  6927.,  7422.,
      40576., 41832., 50080.,  51680.,  51280.,  52920.,  29104., 30100.,
      50310., 52120., 61600.,  63900.,  62850.,  65200.,  35195., 36620.,
      58630., 60760., 71600.,  74300.,  72850.,  75600.,  40715., 42380.,
      22654., 24028., 26960.,  28700.,  27410.,  29180.,  14415., 15486.,
      72320., 74600., 88480.,  91360.,  89680.,  92600.,  50608., 52372.,
      83590., 86680., 101600., 105500., 102850., 106800., 57275., 59660.,
      91910., 95320., 111600., 115900., 112850., 117200., 62795., 65420.,
      34942., 37084., 41360.,  44060.,  41810.,  44540.,  21903., 23550.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15975., 16450., 17225., 17750.,  25975.,  26850.,  27225.,  28150.,
      55975., 58050., 57225., 59350.,  65975.,  68450.,  67225.,  69750.,
      95975., 99650., 97225., 100950., 105975., 110050., 107225., 111350.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17432.,  17664.,  17896.,  18128.,  23040.,  23360.,  23680.,  24000.,
      25400.,  25760.,  26120.,  26480.,  14972.,  15200.,  15428.,  15656.,
      33530.,  34060.,  34590.,  35120.,  42500.,  43200.,  43900.,  44600.,
      44950.,  45700.,  46450.,  47200.,  25765.,  26230.,  26695.,  27160.,
      49850.,  50700.,  51550.,  52400.,  62100.,  63200.,  64300.,  65400.,
      64550.,  65700.,  66850.,  68000.,  36565.,  37270.,  37975.,  38680.,
      20126.,  20732.,  21338.,  21944.,  24340.,  25120.,  25900.,  26680.,
      25210.,  26020.,  26830.,  27640.,  13359.,  13854.,  14349.,  14844.,
      79896.,  81152.,  82408.,  83664.,  98560.,  100160., 101760., 103360.,
      100920., 102560., 104200., 105840., 57212.,  58208.,  59204.,  60200.,
      98810.,  100620., 102430., 104240., 120900., 123200., 125500., 127800.,
      123350., 125700., 128050., 130400., 68965.,  70390.,  71815.,  73240.,
      115130., 117260., 119390., 121520., 140500., 143200., 145900., 148600.,
      142950., 145700., 148450., 151200., 79765.,  81430.,  83095.,  84760.,
      43934.,  45308.,  46682.,  48056.,  52180.,  53920.,  55660.,  57400.,
      53050.,  54820.,  56590.,  58360.,  27759.,  28830.,  29901.,  30972.,
      142360., 144640., 146920., 149200., 174080., 176960., 179840., 182720.,
      176440., 179360., 182280., 185200., 99452.,  101216., 102980., 104744.,
      164090., 167180., 170270., 173360., 199300., 203200., 207100., 211000.,
      201750., 205700., 209650., 213600., 112165., 114550., 116935., 119320.,
      180410., 183820., 187230., 190640., 218900., 223200., 227500., 231800.,
      221350., 225700., 230050., 234400., 122965., 125590., 128215., 130840.,
      67742.,  69884.,  72026.,  74168.,  80020.,  82720.,  85420.,  88120.,
      80890.,  83620.,  86350.,  89080.,  42159.,  43806.,  45453.,  47100.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31475.,  31950.,  32425.,  32900.,  33925.,  34450.,  34975.,  35500.,
      51075.,  51950.,  52825.,  53700.,  53525.,  54450.,  55375.,  56300.,
      109875., 111950., 114025., 116100., 112325., 114450., 116575., 118700.,
      129475., 131950., 134425., 136900., 131925., 134450., 136975., 139500.,
      188275., 191950., 195625., 199300., 190725., 194450., 198175., 201900.,
      207875., 211950., 216025., 220100., 210325., 214450., 218575., 222700.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35296.,  46760.,  51640.,  30520.,  68660.,  87175.,  92275.,  53045.,
      102580., 127975., 133075., 75605.,  42484.,  51575.,  53435.,  28581.,
      164320., 202920., 207800., 118072., 204340., 250375., 255475., 143285.,
      238260., 291175., 296275., 165845., 93172.,  111095., 112955., 59685.,
      293344., 359080., 363960., 205624., 340020., 413575., 418675., 233525.,
      373940., 454375., 459475., 256085., 143860., 170615., 172475., 90789.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {64225.,  69325.,  105025., 110125.,
                                         227425., 232525., 268225., 273325.,
                                         390625., 395725., 431425., 436525.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69680.,  70592.,  92260.,  93520.,  101860., 103280., 60140.,  61040.,
      135220., 137320., 171575., 174350., 181575., 184550., 104245., 106090.,
      201780., 205160., 251575., 255950., 261575., 266150., 148405., 151210.,
      82556.,  84968.,  100045., 103150., 103645., 106870., 55191.,  57162.,
      323632., 328640., 399460., 405840., 409060., 415600., 232172., 236144.,
      401460., 408680., 491575., 500750., 501575., 510950., 280885., 286570.,
      468020., 476520., 571575., 582350., 581575., 592550., 325045., 331690.,
      180860., 186344., 215245., 222190., 218845., 225910., 115095., 119370.,
      577584., 586688., 706660., 718160., 716260., 727920., 404204., 411248.,
      667700., 680040., 811575., 827150., 821575., 837350., 457525., 467050.,
      734260., 747880., 891575., 908750., 901575., 918950., 501685., 512170.,
      279164., 287720., 330445., 341230., 334045., 344950., 174999., 181578.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      126575., 128450., 136575., 138650., 206575., 210050., 216575., 220250.,
      446575., 454850., 456575., 465050., 526575., 536450., 536575., 546650.,
      766575., 781250., 776575., 791450., 846575., 862850., 856575., 873050.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      138448.,  139360.,  140272.,  141184.,  183260.,  184520.,  185780.,
      187040.,  202300.,  203720.,  205140.,  206560.,  119380.,  120280.,
      121180.,  122080.,  268340.,  270440.,  272540.,  274640.,  340375.,
      343150.,  345925.,  348700.,  360175.,  363150.,  366125.,  369100.,
      206645.,  208490.,  210335.,  212180.,  400180.,  403560.,  406940.,
      410320.,  498775.,  503150.,  507525.,  511900.,  518575.,  523150.,
      527725.,  532300.,  294005.,  296810.,  299615.,  302420.,  162700.,
      165112.,  167524.,  169936.,  196985.,  200090.,  203195.,  206300.,
      204065.,  207290.,  210515.,  213740.,  108411.,  110382.,  112353.,
      114324.,  642256.,  647264.,  652272.,  657280.,  792540.,  798920.,
      805300.,  811680.,  811580.,  818120.,  824660.,  831200.,  460372.,
      464344.,  468316.,  472288.,  795700.,  802920.,  810140.,  817360.,
      973975.,  983150.,  992325.,  1001500., 993775.,  1003150., 1012525.,
      1021900., 556085.,  561770.,  567455.,  573140.,  927540.,  936040.,
      944540.,  953040.,  1132375., 1143150., 1153925., 1164700., 1152175.,
      1163150., 1174125., 1185100., 643445.,  650090.,  656735.,  663380.,
      356236.,  361720.,  367204.,  372688.,  423545.,  430490.,  437435.,
      444380.,  430625.,  437690.,  444755.,  451820.,  225915.,  230190.,
      234465.,  238740.,  1146064., 1155168., 1164272., 1173376., 1401820.,
      1413320., 1424820., 1436320., 1420860., 1432520., 1444180., 1455840.,
      801364.,  808408.,  815452.,  822496.,  1323060., 1335400., 1347740.,
      1360080., 1607575., 1623150., 1638725., 1654300., 1627375., 1643150.,
      1658925., 1674700., 905525.,  915050.,  924575.,  934100.,  1454900.,
      1468520., 1482140., 1495760., 1765975., 1783150., 1800325., 1817500.,
      1785775., 1803150., 1820525., 1837900., 992885.,  1003370., 1013855.,
      1024340., 549772.,  558328.,  566884.,  575440.,  650105.,  660890.,
      671675.,  682460.,  657185.,  668090.,  678995.,  689900.,  343419.,
      349998.,  356577.,  363156.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      251275.,  253150.,  255025.,  256900.,  271075.,  273150.,  275225.,
      277300.,  409675.,  413150.,  416625.,  420100.,  429475.,  433150.,
      436825.,  440500.,  884875.,  893150.,  901425.,  909700.,  904675.,
      913150.,  921625.,  930100.,  1043275., 1053150., 1063025., 1072900.,
      1063075., 1073150., 1083225., 1093300., 1518475., 1533150., 1547825.,
      1562500., 1538275., 1553150., 1568025., 1582900., 1676875., 1693150.,
      1709425., 1725700., 1696675., 1713150., 1729625., 1746100.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      278560.,  369160.,  407880.,  241016.,  543000.,  689350.,  729750.,
      419290.,  811800.,  1012550., 1052950., 597850.,  334280.,  405490.,
      420130.,  224238.,  1302560., 1608200., 1646920., 935288.,  1618200.,
      1982150., 2022550., 1133530., 1887000., 2305350., 2345750., 1312090.,
      733640.,  873970.,  888610.,  468462.,  2326560., 2847240., 2885960.,
      1629560., 2693400., 3274950., 3315350., 1847770., 2962200., 3598150.,
      3638550., 2026330., 1133000., 1342450., 1357090., 712686.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      507550.,  547950.,  830750.,  871150.,  1800350., 1840750.,
      2123550., 2163950., 3093150., 3133550., 3416350., 3456750.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      553504.,  557120.,  733320.,  738320.,  810120.,  815760.,  478456.,
      482032.,  1077640., 1086000., 1367650., 1378700., 1447650., 1459500.,
      831230.,  838580.,  1610120., 1623600., 2007650., 2025100., 2087650.,
      2105900., 1184510., 1195700., 658936.,  668560.,  798590.,  810980.,
      827390.,  840260.,  440610.,  448476.,  2585120., 2605120., 3190920.,
      3216400., 3267720., 3293840., 1854712., 1870576., 3207560., 3236400.,
      3927650., 3964300., 4007650., 4045100., 2244350., 2267060., 3740040.,
      3774000., 4567650., 4610700., 4647650., 4691500., 2597630., 2624180.,
      1445368., 1467280., 1720190., 1747940., 1748990., 1777220., 919842.,
      936924.,  4616736., 4653120., 5648520., 5694480., 5725320., 5771920.,
      3230968., 3259120., 5337480., 5386800., 6487650., 6549900., 6567650.,
      6630700., 3657470., 3695540., 5869960., 5924400., 7127650., 7196300.,
      7207650., 7277100., 4010750., 4052660., 2231800., 2266000., 2641790.,
      2684900., 2670590., 2714180., 1399074., 1425372.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1007650., 1015100., 1087650., 1095900., 1647650., 1661500.,
      1727650., 1742300., 3567650., 3600700., 3647650., 3681500.,
      4207650., 4247100., 4287650., 4327900., 6127650., 6186300.,
      6207650., 6267100., 6767650., 6832700., 6847650., 6913500.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1103392.,  1107008.,  1110624.,  1114240.,  1461640.,  1466640.,
      1471640.,  1476640.,  1614600.,  1620240.,  1625880.,  1631520.,
      953336.,   956912.,   960488.,   964064.,   2146920.,  2155280.,
      2163640.,  2172000.,  2724250.,  2735300.,  2746350.,  2757400.,
      2883450.,  2895300.,  2907150.,  2919000.,  1655110.,  1662460.,
      1669810.,  1677160.,  3206760.,  3220240.,  3233720.,  3247200.,
      3997850.,  4015300.,  4032750.,  4050200.,  4157050.,  4175300.,
      4193550.,  4211800.,  2357830.,  2369020.,  2380210.,  2391400.,
      1308248.,  1317872.,  1327496.,  1337120.,  1584790.,  1597180.,
      1609570.,  1621960.,  1641910.,  1654780.,  1667650.,  1680520.,
      873354.,   881220.,   889086.,   896952.,   5150240.,  5170240.,
      5190240.,  5210240.,  6356360.,  6381840.,  6407320.,  6432800.,
      6509320.,  6535440.,  6561560.,  6587680.,  3693560.,  3709424.,
      3725288.,  3741152.,  6386280.,  6415120.,  6443960.,  6472800.,
      7818650.,  7855300.,  7891950.,  7928600.,  7977850.,  8015300.,
      8052750.,  8090200.,  4465990.,  4488700.,  4511410.,  4534120.,
      7446120.,  7480080.,  7514040.,  7548000.,  9092250.,  9135300.,
      9178350.,  9221400.,  9251450.,  9295300.,  9339150.,  9383000.,
      5168710.,  5195260.,  5221810.,  5248360.,  2868824.,  2890736.,
      2912648.,  2934560.,  3412630.,  3440380.,  3468130.,  3495880.,
      3469750.,  3497980.,  3526210.,  3554440.,  1822602.,  1839684.,
      1856766.,  1873848.,  9197088.,  9233472.,  9269856.,  9306240.,
      11251080., 11297040., 11343000., 11388960., 11404040., 11450640.,
      11497240., 11543840., 6433784.,  6461936.,  6490088.,  6518240.,
      10625640., 10674960., 10724280., 10773600., 12913050., 12975300.,
      13037550., 13099800., 13072250., 13135300., 13198350., 13261400.,
      7276870.,  7314940.,  7353010.,  7391080.,  11685480., 11739920.,
      11794360., 11848800., 14186650., 14255300., 14323950., 14392600.,
      14345850., 14415300., 14484750., 14554200., 7979590.,  8021500.,
      8063410.,  8105320.,  4429400.,  4463600.,  4497800.,  4532000.,
      5240470.,  5283580.,  5326690.,  5369800.,  5297590.,  5341180.,
      5384770.,  5428360.,  2771850.,  2798148.,  2824446.,  2850744.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2007850.,  2015300.,  2022750.,  2030200.,  2167050.,  2175300.,
      2183550.,  2191800.,  3281450.,  3295300.,  3309150.,  3323000.,
      3440650.,  3455300.,  3469950.,  3484600.,  7102250.,  7135300.,
      7168350.,  7201400.,  7261450.,  7295300.,  7329150.,  7363000.,
      8375850.,  8415300.,  8454750.,  8494200.,  8535050.,  8575300.,
      8615550.,  8655800.,  12196650., 12255300., 12313950., 12372600.,
      12355850., 12415300., 12474750., 12534200., 13470250., 13535300.,
      13600350., 13665400., 13629450., 13695300., 13761150., 13827000.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5500.,  7180.,  7800.,  8420.,  4934.,  10800., 13600., 14250., 14900.,
      8530.,  16200., 20100., 20750., 21400., 12130., 6790.,  8210.,  8450.,
      8690.,  4653.,  25980., 31980., 32600., 33220., 18854., 32400., 39600.,
      40250., 40900., 22930., 37800., 46100., 46750., 47400., 26530., 14950.,
      17810., 18050., 18290., 9693.,  46460., 56780., 57400., 58020., 32774.,
      54000., 65600., 66250., 66900., 37330., 59400., 72100., 72750., 73400.,
      40930., 23110., 27410., 27650., 27890., 14733.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10025., 10675., 11325., 16525., 17175., 17825., 36025., 36675., 37325.,
      42525., 43175., 43825., 62025., 62675., 63325., 68525., 69175., 69825.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10720.,  11000.,  13980.,  14360.,  15180.,  15600.,  16380.,  16840.,
      9580.,   9868.,   20950.,  21600.,  26350.,  27200.,  27600.,  28500.,
      28850.,  29800.,  16475.,  17060.,  31350.,  32400.,  38850.,  40200.,
      40100.,  41500.,  41350.,  42800.,  23375.,  24260.,  12830.,  13580.,
      15460.,  16420.,  15910.,  16900.,  16360.,  17380.,  8685.,   9306.,
      50400.,  51960.,  61980.,  63960.,  63180.,  65200.,  64380.,  66440.,
      36460.,  37708.,  62550.,  64800.,  76350.,  79200.,  77600.,  80500.,
      78850.,  81800.,  44075.,  45860.,  72950.,  75600.,  88850.,  92200.,
      90100.,  93500.,  91350.,  94800.,  50975.,  53060.,  28190.,  29900.,
      33460.,  35620.,  33910.,  36100.,  34360.,  36580.,  18045.,  19386.,
      90080.,  92920.,  109980., 113560., 111180., 114800., 112380., 116040.,
      63340.,  65548.,  104150., 108000., 126350., 131200., 127600., 132500.,
      128850., 133800., 71675.,  74660.,  114550., 118800., 138850., 144200.,
      140100., 145500., 141350., 146800., 78575.,  81860.,  43550.,  46220.,
      51460.,  54820.,  51910.,  55300.,  52360.,  55780.,  27405.,  29466.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19475.,  20050.,  20725.,  21350.,  21975.,  22650.,  31975.,  33050.,
      33225.,  34350.,  34475.,  35650.,  69475.,  72050.,  70725.,  73350.,
      71975.,  74650.,  81975.,  85050.,  83225.,  86350.,  84475.,  87650.,
      119475., 124050., 120725., 125350., 121975., 126650., 131975., 137050.,
      133225., 138350., 134475., 139650.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21160.,  21440.,  21720.,  22000.,  27580.,  27960.,  28340.,  28720.,
      29940.,  30360.,  30780.,  31200.,  32300.,  32760.,  33220.,  33680.,
      18872.,  19160.,  19448.,  19736.,  41250.,  41900.,  42550.,  43200.,
      51850.,  52700.,  53550.,  54400.,  54300.,  55200.,  56100.,  57000.,
      56750.,  57700.,  58650.,  59600.,  32365.,  32950.,  33535.,  34120.,
      61650.,  62700.,  63750.,  64800.,  76350.,  77700.,  79050.,  80400.,
      78800.,  80200.,  81600.,  83000.,  81250.,  82700.,  84150.,  85600.,
      45865.,  46750.,  47635.,  48520.,  24910.,  25660.,  26410.,  27160.,
      29960.,  30920.,  31880.,  32840.,  30830.,  31820.,  32810.,  33800.,
      31700.,  32720.,  33740.,  34760.,  16749.,  17370.,  17991.,  18612.,
      99240.,  100800., 102360., 103920., 121980., 123960., 125940., 127920.,
      124340., 126360., 128380., 130400., 126700., 128760., 130820., 132880.,
      71672.,  72920.,  74168.,  75416.,  122850., 125100., 127350., 129600.,
      149850., 152700., 155550., 158400., 152300., 155200., 158100., 161000.,
      154750., 157700., 160650., 163600., 86365.,  88150.,  89935.,  91720.,
      143250., 145900., 148550., 151200., 174350., 177700., 181050., 184400.,
      176800., 180200., 183600., 187000., 179250., 182700., 186150., 189600.,
      99865.,  101950., 104035., 106120., 54670.,  56380.,  58090.,  59800.,
      64760.,  66920.,  69080.,  71240.,  65630.,  67820.,  70010.,  72200.,
      66500.,  68720.,  70940.,  73160.,  34749.,  36090.,  37431.,  38772.,
      177320., 180160., 183000., 185840., 216380., 219960., 223540., 227120.,
      218740., 222360., 225980., 229600., 221100., 224760., 228420., 232080.,
      124472., 126680., 128888., 131096., 204450., 208300., 212150., 216000.,
      247850., 252700., 257550., 262400., 250300., 255200., 260100., 265000.,
      252750., 257700., 262650., 267600., 140365., 143350., 146335., 149320.,
      224850., 229100., 233350., 237600., 272350., 277700., 283050., 288400.,
      274800., 280200., 285600., 291000., 277250., 282700., 288150., 293600.,
      153865., 157150., 160435., 163720., 84430.,  87100.,  89770.,  92440.,
      99560.,  102920., 106280., 109640., 100430., 103820., 107210., 110600.,
      101300., 104720., 108140., 111560., 52749.,  54810.,  56871.,  58932.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38375.,  38950.,  39525.,  40100.,  40825.,  41450.,  42075.,  42700.,
      43275.,  43950.,  44625.,  45300.,  62875.,  63950.,  65025.,  66100.,
      65325.,  66450.,  67575.,  68700.,  67775.,  68950.,  70125.,  71300.,
      136375., 138950., 141525., 144100., 138825., 141450., 144075., 146700.,
      141275., 143950., 146625., 149300., 160875., 163950., 167025., 170100.,
      163325., 166450., 169575., 172700., 165775., 168950., 172125., 175300.,
      234375., 238950., 243525., 248100., 236825., 241450., 246075., 250700.,
      239275., 243950., 248625., 253300., 258875., 263950., 269025., 274100.,
      261325., 266450., 271575., 276700., 263775., 268950., 274125., 279300.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42944.,  56080.,  60960.,  65840.,  38560.,  84580.,  106475., 111575.,
      116675., 66725.,  126980., 157475., 162575., 167675., 94925.,  52628.,
      63535.,  65395.,  67255.,  35865.,  204224., 251280., 256160., 261040.,
      148000., 254180., 310475., 315575., 320675., 179525., 296580., 361475.,
      366575., 371675., 207725., 115988., 137935., 139795., 141655., 74745.,
      365504., 446480., 451360., 456240., 257440., 423780., 514475., 519575.,
      524675., 292325., 466180., 565475., 570575., 575675., 320525., 179348.,
      212335., 214195., 216055., 113625.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      78425.,  83525.,  88625.,  129425., 134525., 139625.,
      282425., 287525., 292625., 333425., 338525., 343625.,
      486425., 491525., 496625., 537425., 542525., 547625.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84784.,   85888.,   110660.,  112160.,  120260.,  121920.,  129860.,
      131680.,  75980.,   77120.,   166580.,  169160.,  209575.,  212950.,
      219575.,  223150.,  229575.,  233350.,  131125.,  133450.,  249780.,
      253960.,  309575.,  314950.,  319575.,  325150.,  329575.,  335350.,
      186325.,  189850.,  102268.,  105256.,  123245.,  127070.,  126845.,
      130790.,  130445.,  134510.,  69255.,   71730.,   402224.,  408448.,
      494660.,  502560.,  504260.,  512320.,  513860.,  522080.,  291020.,
      296000.,  499380.,  508360.,  609575.,  620950.,  619575.,  631150.,
      629575.,  641350.,  351925.,  359050.,  582580.,  593160.,  709575.,
      722950.,  719575.,  733150.,  729575.,  743350.,  407125.,  415450.,
      225148.,  231976.,  267245.,  275870.,  270845.,  279590.,  274445.,
      283310.,  144135.,  149490.,  719664.,  731008.,  878660.,  892960.,
      888260.,  902720.,  897860.,  912480.,  506060.,  514880.,  832180.,
      847560.,  1009575., 1028950., 1019575., 1039150., 1029575., 1049350.,
      572725.,  584650.,  915380.,  932360.,  1109575., 1130950., 1119575.,
      1141150., 1129575., 1151350., 627925.,  641050.,  348028.,  358696.,
      411245.,  424670.,  414845.,  428390.,  418445.,  432110.,  219015.,
      227250.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      154575.,  156850.,  164575.,  167050.,  174575.,  177250.,
      254575.,  258850.,  264575.,  269050.,  274575.,  279250.,
      554575.,  564850.,  564575.,  575050.,  574575.,  585250.,
      654575.,  666850.,  664575.,  677050.,  674575.,  687250.,
      954575.,  972850.,  964575.,  983050.,  974575.,  993250.,
      1054575., 1074850., 1064575., 1085050., 1074575., 1095250.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      168464.,  169568.,  170672.,  171776.,  219820.,  221320.,  222820.,
      224320.,  238860.,  240520.,  242180.,  243840.,  257900.,  259720.,
      261540.,  263360.,  150820.,  151960.,  153100.,  154240.,  330580.,
      333160.,  335740.,  338320.,  415775.,  419150.,  422525.,  425900.,
      435575.,  439150.,  442725.,  446300.,  455375.,  459150.,  462925.,
      466700.,  259925.,  262250.,  264575.,  266900.,  495380.,  499560.,
      503740.,  507920.,  613775.,  619150.,  624525.,  629900.,  633575.,
      639150.,  644725.,  650300.,  653375.,  659150.,  664925.,  670700.,
      369125.,  372650.,  376175.,  379700.,  201548.,  204536.,  207524.,
      210512.,  242665.,  246490.,  250315.,  254140.,  249745.,  253690.,
      257635.,  261580.,  256825.,  260890.,  264955.,  269020.,  136035.,
      138510.,  140985.,  143460.,  798224.,  804448.,  810672.,  816896.,
      981420.,  989320.,  997220.,  1005120., 1000460., 1008520., 1016580.,
      1024640., 1019500., 1027720., 1035940., 1044160., 577060.,  582040.,
      587020.,  592000.,  989780.,  998760.,  1007740., 1016720., 1207775.,
      1219150., 1230525., 1241900., 1227575., 1239150., 1250725., 1262300.,
      1247375., 1259150., 1270925., 1282700., 696725.,  703850.,  710975.,
      718100.,  1154580., 1165160., 1175740., 1186320., 1405775., 1419150.,
      1432525., 1445900., 1425575., 1439150., 1452725., 1466300., 1445375.,
      1459150., 1472925., 1486700., 805925.,  814250.,  822575.,  830900.,
      443468.,  450296.,  457124.,  463952.,  525865.,  534490.,  543115.,
      551740.,  532945.,  541690.,  550435.,  559180.,  540025.,  548890.,
      557755.,  566620.,  282915.,  288270.,  293625.,  298980.,  1427984.,
      1439328., 1450672., 1462016., 1743020., 1757320., 1771620., 1785920.,
      1762060., 1776520., 1790980., 1805440., 1781100., 1795720., 1810340.,
      1824960., 1003300., 1012120., 1020940., 1029760., 1648980., 1664360.,
      1679740., 1695120., 1999775., 2019150., 2038525., 2057900., 2019575.,
      2039150., 2058725., 2078300., 2039375., 2059150., 2078925., 2098700.,
      1133525., 1145450., 1157375., 1169300., 1813780., 1830760., 1847740.,
      1864720., 2197775., 2219150., 2240525., 2261900., 2217575., 2239150.,
      2260725., 2282300., 2237375., 2259150., 2280925., 2302700., 1242725.,
      1255850., 1268975., 1282100., 685388.,  696056.,  706724.,  717392.,
      809065.,  822490.,  835915.,  849340.,  816145.,  829690.,  843235.,
      856780.,  823225.,  836890.,  850555.,  864220.,  429795.,  438030.,
      446265.,  454500.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      306875.,  309150.,  311425.,  313700.,  326675.,  329150.,  331625.,
      334100.,  346475.,  349150.,  351825.,  354500.,  504875.,  509150.,
      513425.,  517700.,  524675.,  529150.,  533625.,  538100.,  544475.,
      549150.,  553825.,  558500.,  1098875., 1109150., 1119425., 1129700.,
      1118675., 1129150., 1139625., 1150100., 1138475., 1149150., 1159825.,
      1170500., 1296875., 1309150., 1321425., 1333700., 1316675., 1329150.,
      1341625., 1354100., 1336475., 1349150., 1361825., 1374500., 1890875.,
      1909150., 1927425., 1945700., 1910675., 1929150., 1947625., 1966100.,
      1930475., 1949150., 1967825., 1986500., 2088875., 2109150., 2129425.,
      2149700., 2108675., 2129150., 2149625., 2170100., 2128475., 2149150.,
      2169825., 2190500.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      339360.,  443240.,  481960.,  520680.,  304856.,  669400.,  842550.,
      882950.,  923350.,  527770.,  1005400., 1246550., 1286950., 1327350.,
      750970.,  414280.,  499730.,  514370.,  529010.,  281502.,  1619360.,
      1992040., 2030760., 2069480., 1172696., 2013400., 2458550., 2498950.,
      2539350., 1420570., 2349400., 2862550., 2902950., 2943350., 1643770.,
      913480.,  1085330., 1099970., 1114610., 586782.,  2899360., 3540840.,
      3579560., 3618280., 2040536., 3357400., 4074550., 4114950., 4155350.,
      2313370., 3693400., 4478550., 4518950., 4559350., 2536570., 1412680.,
      1670930., 1685570., 1700210., 892062.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      620350.,  660750.,  701150.,  1024350., 1064750., 1105150.,
      2236350., 2276750., 2317150., 2640350., 2680750., 2721150.,
      3852350., 3892750., 3933150., 4256350., 4296750., 4337150.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      674336.,  678720.,  880520.,  886480.,  957320.,  963920.,  1034120.,
      1041360., 605176.,  609712.,  1328520., 1338800., 1671650., 1685100.,
      1751650., 1765900., 1831650., 1846700., 1046270., 1055540., 1994120.,
      2010800., 2471650., 2493100., 2551650., 2573900., 2631650., 2654700.,
      1487870., 1501940., 816632.,  828560.,  984190.,  999460.,  1012990.,
      1028740., 1041790., 1058020., 553122.,  563004.,  3213856., 3238720.,
      3952520., 3984080., 4029320., 4061520., 4106120., 4138960., 2325496.,
      2345392., 3990920., 4026800., 4871650., 4917100., 4951650., 4997900.,
      5031650., 5078700., 2812670., 2841140., 4656520., 4698800., 5671650.,
      5725100., 5751650., 5805900., 5831650., 5886700., 3254270., 3287540.,
      1799672., 1826960., 2136190., 2170660., 2164990., 2199940., 2193790.,
      2229220., 1152162., 1173564., 5753376., 5798720., 7024520., 7081680.,
      7101320., 7159120., 7178120., 7236560., 4045816., 4081072., 6653320.,
      6714800., 8071650., 8149100., 8151650., 8229900., 8231650., 8310700.,
      4579070., 4626740., 7318920., 7386800., 8871650., 8957100., 8951650.,
      9037900., 9031650., 9118700., 5020670., 5073140., 2782712., 2825360.,
      3288190., 3341860., 3316990., 3371140., 3345790., 3400420., 1751202.,
      1784124.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1231650., 1240700., 1311650., 1321500., 1391650., 1402300.,
      2031650., 2048700., 2111650., 2129500., 2191650., 2210300.,
      4431650., 4472700., 4511650., 4553500., 4591650., 4634300.,
      5231650., 5280700., 5311650., 5361500., 5391650., 5442300.,
      7631650., 7704700., 7711650., 7785500., 7791650., 7866300.,
      8431650., 8512700., 8511650., 8593500., 8591650., 8674300.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x8x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1344288., 1348672., 1353056., 1357440., 1755080., 1761040., 1767000.,
      1772960., 1908040., 1914640., 1921240., 1927840., 2061000., 2068240.,
      2075480., 2082720., 1205816., 1210352., 1214888., 1219424., 2646760.,
      2657040., 2667320., 2677600., 3329850., 3343300., 3356750., 3370200.,
      3489050., 3503300., 3517550., 3531800., 3648250., 3663300., 3678350.,
      3693400., 2083270., 2092540., 2101810., 2111080., 3971560., 3988240.,
      4004920., 4021600., 4921850., 4943300., 4964750., 4986200., 5081050.,
      5103300., 5125550., 5147800., 5240250., 5263300., 5286350., 5309400.,
      2961670., 2975740., 2989810., 3003880., 1621336., 1633264., 1645192.,
      1657120., 1953110., 1968380., 1983650., 1998920., 2010230., 2025980.,
      2041730., 2057480., 2067350., 2083580., 2099810., 2116040., 1096362.,
      1106244., 1116126., 1126008., 6402848., 6427712., 6452576., 6477440.,
      7873480., 7905040., 7936600., 7968160., 8026440., 8058640., 8090840.,
      8123040., 8179400., 8212240., 8245080., 8277920., 4631096., 4650992.,
      4670888., 4690784., 4939496., 4967184., 4994872., 5022560., 6021690.,
      6056900., 6092110., 6127320., 6180890., 6216900., 6252910., 6288920.,
      5099002., 5131716., 5164430., 5197144., 2379462., 2397692., 2415922.,
      2434152., 2217448., 2235152., 2252856., 2270560., 2718970., 2741700.,
      2764430., 2787160., 2878170., 2901700., 2925230., 2948760., 2451642.,
      2471876., 2492110., 2512344., 1172998., 1183740., 1194482., 1205224.,
      450904.,  453616.,  456328.,  459040.,  582230.,  585980.,  589730.,
      593480.,  639350.,  643580.,  647810.,  652040.,  696470.,  701180.,
      705890.,  710600.,  384426.,  387396.,  390366.,  393336.,  3367712.,
      3380288., 3392864., 3405440., 4202440., 4218640., 4234840., 4251040.,
      4355400., 4372240., 4389080., 4405920., 4508360., 4525840., 4543320.,
      4560800., 2575928., 2586608., 2597288., 2607968., 4766440., 4786960.,
      4807480., 4828000., 5877050., 5903300., 5929550., 5955800., 6036250.,
      6063300., 6090350., 6117400., 6195450., 6223300., 6251150., 6279000.,
      3488710., 3505660., 3522610., 3539560., 6091240., 6118160., 6145080.,
      6172000., 7469050., 7503300., 7537550., 7571800., 7628250., 7663300.,
      7698350., 7733400., 7787450., 7823300., 7859150., 7895000., 4367110.,
      4388860., 4410610., 4432360., 2401624., 2419696., 2437768., 2455840.,
      2867030., 2889980., 2912930., 2935880., 2924150., 2947580., 2971010.,
      2994440., 2981270., 3005180., 3029090., 3053000., 1570986., 1585476.,
      1599966., 1614456.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x8x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2454250., 2463300., 2472350., 2481400., 2613450., 2623300., 2633150.,
      2643000., 2772650., 2783300., 2793950., 2804600., 4046250., 4063300.,
      4080350., 4097400., 4205450., 4223300., 4241150., 4259000., 4364650.,
      4383300., 4401950., 4420600., 8822250., 8863300., 8904350., 8945400.,
      8981450., 9023300., 9065150., 9107000., 8339882., 8380484., 8421086.,
      8461688., 3881130., 3909700., 3938270., 3966840., 4040330., 4069700.,
      4099070., 4128440., 3726442., 3754564., 3782686., 3810808., 5001450.,
      5023300., 5045150., 5067000., 5160650., 5183300., 5205950., 5228600.,
      5319850., 5343300., 5366750., 5390200., 6593450., 6623300., 6653150.,
      6683000., 6752650., 6783300., 6813950., 6844600., 6911850., 6943300.,
      6974750., 7006200.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3008.,  5100.,  5720.,  3404.,  5890.,  9600.,  10250., 5920.,  8830.,
      14150., 14800., 8440.,  11770., 18700., 19350., 10960., 4914.,  7460.,
      7700.,  4122.,  16868., 26800., 27420., 15584., 20590., 32350., 33000.,
      18520., 23530., 36900., 37550., 21040., 26470., 41450., 42100., 23560.,
      10584., 15860., 16100., 8532.,  30728., 48500., 49120., 27764., 35290.,
      55100., 55750., 31120., 38230., 59650., 60300., 33640., 41170., 64200.,
      64850., 36160., 16254., 24260., 24500., 12942.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7325.,  7975.,  11875., 12525., 16425., 17075., 30075., 30725., 34625.,
      35275., 39175., 39825., 52825., 53475., 57375., 58025., 61925., 62575.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5866.,  6016.,  9930.,   10200.,  11130.,  11440.,  6610.,  6808.,
      11435., 11780., 18600.,  19200.,  19850.,  20500.,  11435., 11840.,
      17105., 17660., 27350.,  28300.,  28600.,  29600.,  16265., 16880.,
      22775., 23540., 36100.,  37400.,  37350.,  38700.,  21095., 21920.,
      9306.,  9828.,  14035.,  14920.,  14485.,  15400.,  7686.,  8244.,
      32746., 33736., 51930.,  53600.,  53130.,  54840.,  30130., 31168.,
      39785., 41180., 62350.,  64700.,  63600.,  66000.,  35585., 37040.,
      45455., 47060., 71100.,  73800.,  72350.,  75100.,  40415., 42080.,
      51125., 52940., 79850.,  82900.,  81100.,  84200.,  45245., 47120.,
      20016., 21168., 29785.,  31720.,  30235.,  32200.,  15876., 17064.,
      59626., 61456., 93930.,  97000.,  95130.,  98240.,  53650., 55528.,
      68135., 70580., 106100., 110200., 107350., 111500., 59735., 62240.,
      73805., 76460., 114850., 119300., 116100., 120600., 64565., 67280.,
      79475., 82340., 123600., 128400., 124850., 129700., 69395., 72320.,
      30726., 32508., 45535.,  48520.,  45985.,  49000.,  24066., 25884.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14225.,  14650.,  15475.,  15950.,  22975.,  23750.,  24225.,  25050.,
      31725.,  32850.,  32975.,  34150.,  57975.,  60150.,  59225.,  61450.,
      66725.,  69250.,  67975.,  70550.,  75475.,  78350.,  76725.,  79650.,
      101725., 105650., 102975., 106950., 110475., 114750., 111725., 116050.,
      119225., 123850., 120475., 125150.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11582.,  11732.,  11882.,  12032.,  19590.,  19860.,  20130.,  20400.,
      21950.,  22260.,  22570.,  22880.,  13022.,  13220.,  13418.,  13616.,
      22525.,  22870.,  23215.,  23560.,  36600.,  37200.,  37800.,  38400.,
      39050.,  39700.,  40350.,  41000.,  22465.,  22870.,  23275.,  23680.,
      33655.,  34210.,  34765.,  35320.,  53750.,  54700.,  55650.,  56600.,
      56200.,  57200.,  58200.,  59200.,  31915.,  32530.,  33145.,  33760.,
      44785.,  45550.,  46315.,  47080.,  70900.,  72200.,  73500.,  74800.,
      73350.,  74700.,  76050.,  77400.,  41365.,  42190.,  43015.,  43840.,
      18090.,  18612.,  19134.,  19656.,  27185.,  28070.,  28955.,  29840.,
      28055.,  28970.,  29885.,  30800.,  14814.,  15372.,  15930.,  16488.,
      64502.,  65492.,  66482.,  67472.,  102190., 103860., 105530., 107200.,
      104550., 106260., 107970., 109680., 59222.,  60260.,  61298.,  62336.,
      78175.,  79570.,  80965.,  82360.,  122350., 124700., 127050., 129400.,
      124800., 127200., 129600., 132000., 69715.,  71170.,  72625.,  74080.,
      89305.,  90910.,  92515.,  94120.,  139500., 142200., 144900., 147600.,
      141950., 144700., 147450., 150200., 79165.,  80830.,  82495.,  84160.,
      100435., 102250., 104065., 105880., 156650., 159700., 162750., 165800.,
      159100., 162200., 165300., 168400., 88615.,  90490.,  92365.,  94240.,
      38880.,  40032.,  41184.,  42336.,  57635.,  59570.,  61505.,  63440.,
      58505.,  60470.,  62435.,  64400.,  30564.,  31752.,  32940.,  34128.,
      117422., 119252., 121082., 122912., 184790., 187860., 190930., 194000.,
      187150., 190260., 193370., 196480., 105422., 107300., 109178., 111056.,
      133825., 136270., 138715., 141160., 208100., 212200., 216300., 220400.,
      210550., 214700., 218850., 223000., 116965., 119470., 121975., 124480.,
      144955., 147610., 150265., 152920., 225250., 229700., 234150., 238600.,
      227700., 232200., 236700., 241200., 126415., 129130., 131845., 134560.,
      156085., 158950., 161815., 164680., 242400., 247200., 252000., 256800.,
      244850., 249700., 254550., 259400., 135865., 138790., 141715., 144640.,
      59670.,  61452.,  63234.,  65016.,  88085.,  91070.,  94055.,  97040.,
      88955.,  91970.,  94985.,  98000.,  46314.,  48132.,  49950.,  51768.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28025.,  28450.,  28875.,  29300.,  30475.,  30950.,  31425.,  31900.,
      45175.,  45950.,  46725.,  47500.,  47625.,  48450.,  49275.,  50100.,
      62325.,  63450.,  64575.,  65700.,  64775.,  65950.,  67125.,  68300.,
      113775., 115950., 118125., 120300., 116225., 118450., 120675., 122900.,
      130925., 133450., 135975., 138500., 133375., 135950., 138525., 141100.,
      148075., 150950., 153825., 156700., 150525., 153450., 156375., 159300.,
      199525., 203450., 207375., 211300., 201975., 205950., 209925., 213900.,
      216675., 220950., 225225., 229500., 219125., 223450., 227775., 232100.,
      233825., 238450., 243075., 247700., 236275., 240950., 245625., 250300.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23380.,  39660.,  44540.,  26500.,  46025.,  74975.,  80075.,  46205.,
      69125.,  110675., 115775., 65945.,  92225.,  146375., 151475., 85685.,
      38115.,  57685.,  59545.,  31743.,  132580., 210460., 215340., 122260.,
      161525., 253475., 258575., 144905., 184625., 289175., 294275., 164645.,
      207725., 324875., 329975., 184385., 82215.,  122785., 124645., 65763.,
      241780., 381260., 386140., 218020., 277025., 431975., 437075., 243605.,
      300125., 467675., 472775., 263345., 323225., 503375., 508475., 283085.,
      126315., 187885., 189745., 99783.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57125.,  62225.,  92825.,  97925.,  128525., 133625.,
      235625., 240725., 271325., 276425., 307025., 312125.,
      414125., 419225., 449825., 454925., 485525., 490625.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46172.,  46760.,  78260.,  79320.,   87860.,  89080.,   52220.,  53000.,
      90685.,  92050.,  147575., 149950.,  157575., 160150.,  90805.,  92410.,
      136045., 138250., 217575., 221350.,  227575., 231550.,  129445., 131890.,
      181405., 184450., 287575., 292750.,  297575., 302950.,  168085., 171370.,
      74151.,  76230.,  111845., 115370.,  115445., 119090.,  61263.,  63486.,
      261212., 265160., 414260., 420920.,  423860., 430680.,  240380., 244520.,
      317485., 323050., 497575., 506950.,  507575., 517150.,  284005., 289810.,
      362845., 369250., 567575., 578350.,  577575., 588550.,  322645., 329290.,
      408205., 415450., 637575., 649750.,  647575., 659950.,  361285., 368770.,
      159831., 164430., 237845., 245570.,  241445., 249290.,  126783., 131526.,
      476252., 483560., 750260., 762520.,  759860., 772280.,  428540., 436040.,
      544285., 554050., 847575., 863950.,  857575., 874150.,  477205., 487210.,
      589645., 600250., 917575., 935350.,  927575., 945550.,  515845., 526690.,
      635005., 646450., 987575., 1006750., 997575., 1016950., 554485., 566170.,
      245511., 252630., 363845., 375770.,  367445., 379490.,  192303., 199566.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      112575., 114250., 122575., 124450., 182575., 185650., 192575., 195850.,
      252575., 257050., 262575., 267250., 462575., 471250., 472575., 481450.,
      532575., 542650., 542575., 552850., 602575., 614050., 612575., 624250.,
      812575., 828250., 822575., 838450., 882575., 899650., 892575., 909850.,
      952575., 971050., 962575., 981250.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      91756.,   92344.,   92932.,   93520.,   155460.,  156520.,  157580.,
      158640.,  174500.,  175720.,  176940.,  178160.,  103660.,  104440.,
      105220.,  106000.,  180005.,  181370.,  182735.,  184100.,  292775.,
      295150.,  297525.,  299900.,  312575.,  315150.,  317725.,  320300.,
      180005.,  181610.,  183215.,  184820.,  269885.,  272090.,  274295.,
      276500.,  431375.,  435150.,  438925.,  442700.,  451175.,  455150.,
      459125.,  463100.,  256445.,  258890.,  261335.,  263780.,  359765.,
      362810.,  365855.,  368900.,  569975.,  575150.,  580325.,  585500.,
      589775.,  595150.,  600525.,  605900.,  332885.,  336170.,  339455.,
      342740.,  146223.,  148302.,  150381.,  152460.,  220165.,  223690.,
      227215.,  230740.,  227245.,  230890.,  234535.,  238180.,  120303.,
      122526.,  124749.,  126972.,  518476.,  522424.,  526372.,  530320.,
      821860.,  828520.,  835180.,  841840.,  840900.,  847720.,  854540.,
      861360.,  476620.,  480760.,  484900.,  489040.,  629405.,  634970.,
      640535.,  646100.,  985775.,  995150.,  1004525., 1013900., 1005575.,
      1015150., 1024725., 1034300., 562205.,  568010.,  573815.,  579620.,
      719285.,  725690.,  732095.,  738500.,  1124375., 1135150., 1145925.,
      1156700., 1144175., 1155150., 1166125., 1177100., 638645.,  645290.,
      651935.,  658580.,  809165.,  816410.,  823655.,  830900.,  1262975.,
      1275150., 1287325., 1299500., 1282775., 1295150., 1307525., 1319900.,
      715085.,  722570.,  730055.,  737540.,  315063.,  319662.,  324261.,
      328860.,  467965.,  475690.,  483415.,  491140.,  475045.,  482890.,
      490735.,  498580.,  248823.,  253566.,  258309.,  263052.,  945196.,
      952504.,  959812.,  967120.,  1488260., 1500520., 1512780., 1525040.,
      1507300., 1519720., 1532140., 1544560., 849580.,  857080.,  864580.,
      872080.,  1078805., 1088570., 1098335., 1108100., 1678775., 1695150.,
      1711525., 1727900., 1698575., 1715150., 1731725., 1748300., 944405.,
      954410.,  964415.,  974420.,  1168685., 1179290., 1189895., 1200500.,
      1817375., 1835150., 1852925., 1870700., 1837175., 1855150., 1873125.,
      1891100., 1020845., 1031690., 1042535., 1053380., 1258565., 1270010.,
      1281455., 1292900., 1955975., 1975150., 1994325., 2013500., 1975775.,
      1995150., 2014525., 2033900., 1097285., 1108970., 1120655., 1132340.,
      483903.,  491022.,  498141.,  505260.,  715765.,  727690.,  739615.,
      751540.,  722845.,  734890.,  746935.,  758980.,  377343.,  384606.,
      391869.,  399132.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      223475.,  225150.,  226825.,  228500.,  243275.,  245150.,  247025.,
      248900.,  362075.,  365150.,  368225.,  371300.,  381875.,  385150.,
      388425.,  391700.,  500675.,  505150.,  509625.,  514100.,  520475.,
      525150.,  529825.,  534500.,  916475.,  925150.,  933825.,  942500.,
      936275.,  945150.,  954025.,  962900.,  1055075., 1065150., 1075225.,
      1085300., 1074875., 1085150., 1095425., 1105700., 1193675., 1205150.,
      1216625., 1228100., 1213475., 1225150., 1236825., 1248500., 1609475.,
      1625150., 1640825., 1656500., 1629275., 1645150., 1661025., 1676900.,
      1748075., 1765150., 1782225., 1799300., 1767875., 1785150., 1802425.,
      1819700., 1886675., 1905150., 1923625., 1942100., 1906475., 1925150.,
      1943825., 1962500.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184328.,  312760.,  351480.,  209096.,  363850.,  592550.,  632950.,
      365050.,  546970.,  875350.,  915750.,  521290.,  730090.,  1158150.,
      1198550., 677530.,  300150.,  453530.,  468170.,  249030.,  1051208.,
      1667960., 1706680., 968456.,  1279450., 2006550., 2046950., 1146250.,
      1462570., 2289350., 2329750., 1302490., 1645690., 2572150., 2612550.,
      1458730., 647910.,  965930.,  980570.,  516150.,  1918088., 3023160.,
      3061880., 1727816., 2195050., 3420550., 3460950., 1927450., 2378170.,
      3703350., 3743750., 2083690., 2561290., 3986150., 4026550., 2239930.,
      995670.,  1478330., 1492970., 783270.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      451150.,  491550.,  733950.,  774350.,  1016750., 1057150.,
      1865150., 1905550., 2147950., 2188350., 2430750., 2471150.,
      3279150., 3319550., 3561950., 3602350., 3844750., 3885150.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      366328.,  368656.,  621320.,  625520.,  698120.,  702960.,  415096.,
      418192.,  722270.,  727700.,  1175650., 1185100., 1255650., 1265900.,
      723710.,  730100.,  1085150., 1093940., 1735650., 1750700., 1815650.,
      1831500., 1032830., 1042580., 1448030., 1460180., 2295650., 2316300.,
      2375650., 2397100., 1341950., 1355060., 592002.,  600300.,  892990.,
      907060.,  921790.,  936340.,  489186.,  498060.,  2086648., 2102416.,
      3309320., 3335920., 3386120., 3413360., 1920376., 1936912., 2536670.,
      2558900., 3975650., 4013100., 4055650., 4093900., 2269310., 2292500.,
      2899550., 2925140., 4535650., 4578700., 4615650., 4659500., 2578430.,
      2604980., 3262430., 3291380., 5095650., 5144300., 5175650., 5225100.,
      2887550., 2917460., 1277442., 1295820., 1900990., 1931860., 1929790.,
      1961140., 1013346., 1032300., 3806968., 3836176., 5997320., 6046320.,
      6074120., 6123760., 3425656., 3455632., 4351070., 4390100., 6775650.,
      6841100., 6855650., 6921900., 3814910., 3854900., 4713950., 4756340.,
      7335650., 7406700., 7415650., 7487500., 4124030., 4167380., 5076830.,
      5122580., 7895650., 7972300., 7975650., 8053100., 4433150., 4479860.,
      1962882., 1991340., 2908990., 2956660., 2937790., 2985940., 1537506.,
      1566540.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      895650.,  902300.,  975650.,  983100.,  1455650., 1467900.,
      1535650., 1548700., 2015650., 2033500., 2095650., 2114300.,
      3695650., 3730300., 3775650., 3811100., 4255650., 4295900.,
      4335650., 4376700., 4815650., 4861500., 4895650., 4942300.,
      6495650., 6558300., 6575650., 6639100., 7055650., 7123900.,
      7135650., 7204700., 7615650., 7689500., 7695650., 7770300.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      730328.,   732656.,   734984.,   737312.,   1238440.,  1242640.,
      1246840.,  1251040.,  1391400.,  1396240.,  1401080.,  1405920.,
      827096.,   830192.,   833288.,   836384.,   1439110.,  1444540.,
      1449970.,  1455400.,  2341850.,  2351300.,  2360750.,  2370200.,
      2501050.,  2511300.,  2521550.,  2531800.,  1441030.,  1447420.,
      1453810.,  1460200.,  2161510.,  2170300.,  2179090.,  2187880.,
      3456250.,  3471300.,  3486350.,  3501400.,  3615450.,  3631300.,
      3647150.,  3663000.,  2055910.,  2065660.,  2075410.,  2085160.,
      2883910.,  2896060.,  2908210.,  2920360.,  4570650.,  4591300.,
      4611950.,  4632600.,  4729850.,  4751300.,  4772750.,  4794200.,
      2670790.,  2683900.,  2697010.,  2710120.,  1175706.,  1184004.,
      1192302.,  1200600.,  1771910.,  1785980.,  1800050.,  1814120.,
      1829030.,  1843580.,  1858130.,  1872680.,  969498.,   978372.,
      987246.,   996120.,   4157528.,  4173296.,  4189064.,  4204832.,
      6592040.,  6618640.,  6645240.,  6671840.,  6745000.,  6772240.,
      6799480.,  6826720.,  3824216.,  3840752.,  3857288.,  3873824.,
      5051110.,  5073340.,  5095570.,  5117800.,  7913850.,  7951300.,
      7988750.,  8026200.,  8073050.,  8111300.,  8149550.,  8187800.,
      4515430.,  4538620.,  4561810.,  4585000.,  5773510.,  5799100.,
      5824690.,  5850280.,  9028250.,  9071300.,  9114350.,  9157400.,
      9187450.,  9231300.,  9275150.,  9319000.,  5130310.,  5156860.,
      5183410.,  5209960.,  6495910.,  6524860.,  6553810.,  6582760.,
      10142650., 10191300., 10239950., 10288600., 10301850., 10351300.,
      10400750., 10450200., 5745190.,  5775100.,  5805010.,  5834920.,
      2536506.,  2554884.,  2573262.,  2591640.,  3771110.,  3801980.,
      3832850.,  3863720.,  3828230.,  3859580.,  3890930.,  3922280.,
      2007738.,  2026692.,  2045646.,  2064600.,  7584728.,  7613936.,
      7643144.,  7672352.,  11945640., 11994640., 12043640., 12092640.,
      12098600., 12148240., 12197880., 12247520., 6821336.,  6851312.,
      6881288.,  6911264.,  8663110.,  8702140.,  8741170.,  8780200.,
      13485850., 13551300., 13616750., 13682200., 13645050., 13711300.,
      13777550., 13843800., 7589830.,  7629820.,  7669810.,  7709800.,
      9385510.,  9427900.,  9470290.,  9512680.,  14600250., 14671300.,
      14742350., 14813400., 14759450., 14831300., 14903150., 14975000.,
      8204710.,  8248060.,  8291410.,  8334760.,  10107910., 10153660.,
      10199410., 10245160., 15714650., 15791300., 15867950., 15944600.,
      15873850., 15951300., 16028750., 16106200., 8819590.,  8866300.,
      8913010.,  8959720.,  3897306.,  3925764.,  3954222.,  3982680.,
      5770310.,  5817980.,  5865650.,  5913320.,  5827430.,  5875580.,
      5923730.,  5971880.,  3045978.,  3075012.,  3104046.,  3133080.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1784650.,  1791300.,  1797950.,  1804600.,  1943850.,  1951300.,
      1958750.,  1966200.,  2899050.,  2911300.,  2923550.,  2935800.,
      3058250.,  3071300.,  3084350.,  3097400.,  4013450.,  4031300.,
      4049150.,  4067000.,  4172650.,  4191300.,  4209950.,  4228600.,
      7356650.,  7391300.,  7425950.,  7460600.,  7515850.,  7551300.,
      7586750.,  7622200.,  8471050.,  8511300.,  8551550.,  8591800.,
      8630250.,  8671300.,  8712350.,  8753400.,  9585450.,  9631300.,
      9677150.,  9723000.,  9744650.,  9791300.,  9837950.,  9884600.,
      12928650., 12991300., 13053950., 13116600., 13087850., 13151300.,
      13214750., 13278200., 14043050., 14111300., 14179550., 14247800.,
      14202250., 14271300., 14340350., 14409400., 15157450., 15231300.,
      15305150., 15379000., 15316650., 15391300., 15465950., 15540600.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4532.,  6000.,  6620.,  3914.,  8780.,  11150., 11800., 6790.,  13100.,
      16350., 17000., 9670.,  17420., 21550., 22200., 12550., 7118.,  8590.,
      8830.,  4719.,  25012., 30800., 31420., 17834., 30380., 37150., 37800.,
      21190., 34700., 42350., 43000., 24070., 39020., 47550., 48200., 26950.,
      15278., 18190., 18430., 9759.,  45492., 55600., 56220., 31754., 51980.,
      63150., 63800., 35590., 56300., 68350., 69000., 38470., 60620., 73550.,
      74200., 41350., 23438., 27790., 28030., 14799.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8225.,  8875.,  13425., 14075., 18625., 19275., 34225., 34875., 39425.,
      40075., 44625., 45275., 60225., 60875., 65425., 66075., 70625., 71275.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8832.,   9064.,   11680.,  12000.,  12880.,  13240.,  7600.,  7828.,
      17030.,  17560.,  21600.,  22300.,  22850.,  23600.,  13115., 13580.,
      25350.,  26200.,  31600.,  32700.,  32850.,  34000.,  18635., 19340.,
      33670.,  34840.,  41600.,  43100.,  42850.,  44400.,  24155., 25100.,
      13438.,  14236.,  16160.,  17180.,  16610.,  17660.,  8799.,  9438.,
      48512.,  50024.,  59680.,  61600.,  60880.,  62840.,  34480., 35668.,
      58630.,  60760.,  71600.,  74300.,  72850.,  75600.,  40715., 42380.,
      66950.,  69400.,  81600.,  84700.,  82850.,  86000.,  46235., 48140.,
      75270.,  78040.,  91600.,  95100.,  92850.,  96400.,  51755., 53900.,
      28798.,  30556.,  34160.,  36380.,  34610.,  36860.,  18159., 19518.,
      88192.,  90984.,  107680., 111200., 108880., 112440., 61360., 63508.,
      100230., 103960., 121600., 126300., 122850., 127600., 68315., 71180.,
      108550., 112600., 131600., 136700., 132850., 138000., 73835., 76940.,
      116870., 121240., 141600., 147100., 142850., 148400., 79355., 82700.,
      44158.,  46876.,  52160.,  55580.,  52610.,  56060.,  27519., 29598.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15975.,  16450.,  17225.,  17750.,  25975.,  26850.,  27225.,  28150.,
      35975.,  37250.,  37225.,  38550.,  65975.,  68450.,  67225.,  69750.,
      75975.,  78850.,  77225.,  80150.,  85975.,  89250.,  87225.,  90550.,
      115975., 120450., 117225., 121750., 125975., 130850., 127225., 132150.,
      135975., 141250., 137225., 142550.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17432.,  17664.,  17896.,  18128.,  23040.,  23360.,  23680.,  24000.,
      25400.,  25760.,  26120.,  26480.,  14972.,  15200.,  15428.,  15656.,
      33530.,  34060.,  34590.,  35120.,  42500.,  43200.,  43900.,  44600.,
      44950.,  45700.,  46450.,  47200.,  25765.,  26230.,  26695.,  27160.,
      49850.,  50700.,  51550.,  52400.,  62100.,  63200.,  64300.,  65400.,
      64550.,  65700.,  66850.,  68000.,  36565.,  37270.,  37975.,  38680.,
      66170.,  67340.,  68510.,  69680.,  81700.,  83200.,  84700.,  86200.,
      84150.,  85700.,  87250.,  88800.,  47365.,  48310.,  49255.,  50200.,
      26078.,  26876.,  27674.,  28472.,  31300.,  32320.,  33340.,  34360.,
      32170.,  33220.,  34270.,  35320.,  16959.,  17598.,  18237.,  18876.,
      95512.,  97024.,  98536.,  100048., 117440., 119360., 121280., 123200.,
      119800., 121760., 123720., 125680., 67772.,  68960.,  70148.,  71336.,
      115130., 117260., 119390., 121520., 140500., 143200., 145900., 148600.,
      142950., 145700., 148450., 151200., 79765.,  81430.,  83095.,  84760.,
      131450., 133900., 136350., 138800., 160100., 163200., 166300., 169400.,
      162550., 165700., 168850., 172000., 90565.,  92470.,  94375.,  96280.,
      147770., 150540., 153310., 156080., 179700., 183200., 186700., 190200.,
      182150., 185700., 189250., 192800., 101365., 103510., 105655., 107800.,
      55838.,  57596.,  59354.,  61112.,  66100.,  68320.,  70540.,  72760.,
      66970.,  69220.,  71470.,  73720.,  34959.,  36318.,  37677.,  39036.,
      173592., 176384., 179176., 181968., 211840., 215360., 218880., 222400.,
      214200., 217760., 221320., 224880., 120572., 122720., 124868., 127016.,
      196730., 200460., 204190., 207920., 238500., 243200., 247900., 252600.,
      240950., 245700., 250450., 255200., 133765., 136630., 139495., 142360.,
      213050., 217100., 221150., 225200., 258100., 263200., 268300., 273400.,
      260550., 265700., 270850., 276000., 144565., 147670., 150775., 153880.,
      229370., 233740., 238110., 242480., 277700., 283200., 288700., 294200.,
      280150., 285700., 291250., 296800., 155365., 158710., 162055., 165400.,
      85598.,  88316.,  91034.,  93752.,  100900., 104320., 107740., 111160.,
      101770., 105220., 108670., 112120., 52959.,  55038.,  57117.,  59196.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31475.,  31950.,  32425.,  32900.,  33925.,  34450.,  34975.,  35500.,
      51075.,  51950.,  52825.,  53700.,  53525.,  54450.,  55375.,  56300.,
      70675.,  71950.,  73225.,  74500.,  73125.,  74450.,  75775.,  77100.,
      129475., 131950., 134425., 136900., 131925., 134450., 136975., 139500.,
      149075., 151950., 154825., 157700., 151525., 154450., 157375., 160300.,
      168675., 171950., 175225., 178500., 171125., 174450., 177775., 181100.,
      227475., 231950., 236425., 240900., 229925., 234450., 238975., 243500.,
      247075., 251950., 256825., 261700., 249525., 254450., 259375., 264300.,
      266675., 271950., 277225., 282500., 269125., 274450., 279775., 285100.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35296.,  46760.,  51640.,  30520.,  68660.,  87175.,  92275.,  53045.,
      102580., 127975., 133075., 75605.,  136500., 168775., 173875., 98165.,
      55156.,  66455.,  68315.,  36357.,  196576., 241960., 246840., 139960.,
      238260., 291175., 296275., 165845., 272180., 331975., 337075., 188405.,
      306100., 372775., 377875., 210965., 118516., 140855., 142715., 75237.,
      357856., 437160., 442040., 249400., 407860., 495175., 500275., 278645.,
      441780., 535975., 541075., 301205., 475700., 576775., 581875., 323765.,
      181876., 215255., 217115., 114117.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      64225.,  69325.,  105025., 110125., 145825., 150925.,
      268225., 273325., 309025., 314125., 349825., 354925.,
      472225., 477325., 513025., 518125., 553825., 558925.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69680.,   70592.,   92260.,   93520.,   101860.,  103280., 60140.,
      61040.,   135220.,  137320.,  171575.,  174350.,  181575., 184550.,
      104245.,  106090.,  201780.,  205160.,  251575.,  255950., 261575.,
      266150.,  148405.,  151210.,  268340.,  273000.,  331575., 337550.,
      341575.,  347750.,  192565.,  196330.,  107132.,  110312., 128845.,
      132910.,  132445.,  136630.,  70167.,   72714.,   387120., 393152.,
      476260.,  483920.,  485860.,  493680.,  275180.,  279920., 468020.,
      476520.,  571575.,  582350.,  581575.,  592550.,  325045., 331690.,
      534580.,  544360.,  651575.,  663950.,  661575.,  674150., 369205.,
      376810.,  601140.,  612200.,  731575.,  745550.,  741575., 755750.,
      413365.,  421930.,  230012.,  237032.,  272845.,  281710., 276445.,
      285430.,  145047.,  150474.,  704560.,  715712.,  860260., 874320.,
      869860.,  884080.,  490220.,  498800.,  800820.,  815720., 971575.,
      990350.,  981575.,  1000550., 545845.,  557290.,  867380., 883560.,
      1051575., 1071950., 1061575., 1082150., 590005.,  602410., 933940.,
      951400.,  1131575., 1153550., 1141575., 1163750., 634165., 647530.,
      352892.,  363752.,  416845.,  430510.,  420445.,  434230., 219927.,
      228234.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      126575.,  128450.,  136575.,  138650.,  206575.,  210050.,
      216575.,  220250.,  286575.,  291650.,  296575.,  301850.,
      526575.,  536450.,  536575.,  546650.,  606575.,  618050.,
      616575.,  628250.,  686575.,  699650.,  696575.,  709850.,
      926575.,  944450.,  936575.,  954650.,  1006575., 1026050.,
      1016575., 1036250., 1086575., 1107650., 1096575., 1117850.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      138448.,  139360.,  140272.,  141184.,  183260.,  184520.,  185780.,
      187040.,  202300.,  203720.,  205140.,  206560.,  119380.,  120280.,
      121180.,  122080.,  268340.,  270440.,  272540.,  274640.,  340375.,
      343150.,  345925.,  348700.,  360175.,  363150.,  366125.,  369100.,
      206645.,  208490.,  210335.,  212180.,  400180.,  403560.,  406940.,
      410320.,  498775.,  503150.,  507525.,  511900.,  518575.,  523150.,
      527725.,  532300.,  294005.,  296810.,  299615.,  302420.,  532020.,
      536680.,  541340.,  546000.,  657175.,  663150.,  669125.,  675100.,
      676975.,  683150.,  689325.,  695500.,  381365.,  385130.,  388895.,
      392660.,  211084.,  214264.,  217444.,  220624.,  253625.,  257690.,
      261755.,  265820.,  260705.,  264890.,  269075.,  273260.,  137787.,
      140334.,  142881.,  145428.,  768208.,  774240.,  780272.,  786304.,
      944860.,  952520.,  960180.,  967840.,  963900.,  971720.,  979540.,
      987360.,  545620.,  550360.,  555100.,  559840.,  927540.,  936040.,
      944540.,  953040.,  1132375., 1143150., 1153925., 1164700., 1152175.,
      1163150., 1174125., 1185100., 643445.,  650090.,  656735.,  663380.,
      1059380., 1069160., 1078940., 1088720., 1290775., 1303150., 1315525.,
      1327900., 1310575., 1323150., 1335725., 1348300., 730805.,  738410.,
      746015.,  753620.,  1191220., 1202280., 1213340., 1224400., 1449175.,
      1463150., 1477125., 1491100., 1468975., 1483150., 1497325., 1511500.,
      818165.,  826730.,  835295.,  843860.,  453004.,  460024.,  467044.,
      474064.,  536825.,  545690.,  554555.,  563420.,  543905.,  552890.,
      561875.,  570860.,  284667.,  290094.,  295521.,  300948.,  1397968.,
      1409120., 1420272., 1431424., 1706460., 1720520., 1734580., 1748640.,
      1725500., 1739720., 1753940., 1768160., 971860.,  980440.,  989020.,
      997600.,  1586740., 1601640., 1616540., 1631440., 1924375., 1943150.,
      1961925., 1980700., 1944175., 1963150., 1982125., 2001100., 1080245.,
      1091690., 1103135., 1114580., 1718580., 1734760., 1750940., 1767120.,
      2082775., 2103150., 2123525., 2143900., 2102575., 2123150., 2143725.,
      2164300., 1167605., 1180010., 1192415., 1204820., 1850420., 1867880.,
      1885340., 1902800., 2241175., 2263150., 2285125., 2307100., 2260975.,
      2283150., 2305325., 2327500., 1254965., 1268330., 1281695., 1295060.,
      694924.,  705784.,  716644.,  727504.,  820025.,  833690.,  847355.,
      861020.,  827105.,  840890.,  854675.,  868460.,  431547.,  439854.,
      448161.,  456468.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      251275.,  253150.,  255025.,  256900.,  271075.,  273150.,  275225.,
      277300.,  409675.,  413150.,  416625.,  420100.,  429475.,  433150.,
      436825.,  440500.,  568075.,  573150.,  578225.,  583300.,  587875.,
      593150.,  598425.,  603700.,  1043275., 1053150., 1063025., 1072900.,
      1063075., 1073150., 1083225., 1093300., 1201675., 1213150., 1224625.,
      1236100., 1221475., 1233150., 1244825., 1256500., 1360075., 1373150.,
      1386225., 1399300., 1379875., 1393150., 1406425., 1419700., 1835275.,
      1853150., 1871025., 1888900., 1855075., 1873150., 1891225., 1909300.,
      1993675., 2013150., 2032625., 2052100., 2013475., 2033150., 2052825.,
      2072500., 2152075., 2173150., 2194225., 2215300., 2171875., 2193150.,
      2214425., 2235700.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      278560.,  369160.,  407880.,  241016.,  543000.,  689350.,  729750.,
      419290.,  811800.,  1012550., 1052950., 597850.,  1080600., 1335750.,
      1376150., 776410.,  434120.,  522610.,  537250.,  285294.,  1558560.,
      1917960., 1956680., 1108856., 1887000., 2305350., 2345750., 1312090.,
      2155800., 2628550., 2668950., 1490650., 2424600., 2951750., 2992150.,
      1669210., 933320.,  1108210., 1122850., 590574.,  2838560., 3466760.,
      3505480., 1976696., 3231000., 3921350., 3961750., 2204890., 3499800.,
      4244550., 4284950., 2383450., 3768600., 4567750., 4608150., 2562010.,
      1432520., 1693810., 1708450., 895854.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      507550.,  547950.,  830750.,  871150.,  1153950., 1194350.,
      2123550., 2163950., 2446750., 2487150., 2769950., 2810350.,
      3739550., 3779950., 4062750., 4103150., 4385950., 4426350.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      553504.,  557120.,  733320.,  738320.,  810120.,  815760.,  478456.,
      482032.,  1077640., 1086000., 1367650., 1378700., 1447650., 1459500.,
      831230.,  838580.,  1610120., 1623600., 2007650., 2025100., 2087650.,
      2105900., 1184510., 1195700., 2142600., 2161200., 2647650., 2671500.,
      2727650., 2752300., 1537790., 1552820., 855544.,  868240.,  1028990.,
      1045220., 1057790., 1074500., 560418.,  570588.,  3093024., 3117120.,
      3805320., 3835920., 3882120., 3913360., 2198776., 2217712., 3740040.,
      3774000., 4567650., 4610700., 4647650., 4691500., 2597630., 2624180.,
      4272520., 4311600., 5207650., 5257100., 5287650., 5337900., 2950910.,
      2981300., 4805000., 4849200., 5847650., 5903500., 5927650., 5984300.,
      3304190., 3338420., 1838584., 1866640., 2180990., 2216420., 2209790.,
      2245700., 1159458., 1181148., 5632544., 5677120., 6877320., 6933520.,
      6954120., 7010960., 3919096., 3953392., 6402440., 6462000., 7767650.,
      7842700., 7847650., 7923500., 4364030., 4409780., 6934920., 6999600.,
      8407650., 8489100., 8487650., 8569900., 4717310., 4766900., 7467400.,
      7537200., 9047650., 9135500., 9127650., 9216300., 5070590., 5124020.,
      2821624., 2865040., 3332990., 3387620., 3361790., 3416900., 1758498.,
      1791708.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1007650., 1015100., 1087650., 1095900., 1647650., 1661500.,
      1727650., 1742300., 2287650., 2307900., 2367650., 2388700.,
      4207650., 4247100., 4287650., 4327900., 4847650., 4893500.,
      4927650., 4974300., 5487650., 5539900., 5567650., 5620700.,
      7407650., 7479100., 7487650., 7559900., 8047650., 8125500.,
      8127650., 8206300., 8687650., 8771900., 8767650., 8852700.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1103392., 1107008., 1110624., 1114240., 1461640., 1466640., 1471640.,
      1476640., 1614600., 1620240., 1625880., 1631520., 953336.,  956912.,
      960488.,  964064.,  2146920., 2155280., 2163640., 2172000., 2724250.,
      2735300., 2746350., 2757400., 2883450., 2895300., 2907150., 2919000.,
      1655110., 1662460., 1669810., 1677160., 3206760., 3220240., 3233720.,
      3247200., 3997850., 4015300., 4032750., 4050200., 4157050., 4175300.,
      4193550., 4211800., 2357830., 2369020., 2380210., 2391400., 4266600.,
      4285200., 4303800., 4322400., 5271450., 5295300., 5319150., 5343000.,
      5430650., 5455300., 5479950., 5504600., 3060550., 3075580., 3090610.,
      3105640., 1698392., 1711088., 1723784., 1736480., 2041750., 2057980.,
      2074210., 2090440., 2098870., 2115580., 2132290., 2149000., 1110666.,
      1120836., 1131006., 1141176., 6161952., 6186048., 6210144., 6234240.,
      7580040., 7610640., 7641240., 7671840., 7733000., 7764240., 7795480.,
      7826720., 4378616., 4397552., 4416488., 4435424., 7446120., 7480080.,
      7514040., 7548000., 9092250., 9135300., 9178350., 9221400., 9251450.,
      9295300., 9339150., 9383000., 5168710., 5195260., 5221810., 5248360.,
      3148392., 3171088., 3193784., 3216480., 3832730., 3861700., 3890670.,
      3919640., 3991930., 4021700., 4051470., 4081240., 2148166., 2166268.,
      2184370., 2202472., 1472104., 1483536., 1494968., 1506400., 1850010.,
      1864900., 1879790., 1894680., 2009210., 2024900., 2040590., 2056280.,
      1093702., 1103356., 1113010., 1122664., 527960.,  531440.,  534920.,
      538400.,  670870.,  675580.,  680290.,  685000.,  727990.,  733180.,
      738370.,  743560.,  398730.,  401988.,  405246.,  408504.,  3126816.,
      3138624., 3150432., 3162240., 3909000., 3924240., 3939480., 3954720.,
      4061960., 4077840., 4093720., 4109600., 2323448., 2333168., 2342888.,
      2352608., 4266600., 4285200., 4303800., 4322400., 5271450., 5295300.,
      5319150., 5343000., 5430650., 5455300., 5479950., 5504600., 3060550.,
      3075580., 3090610., 3105640., 5326440., 5350160., 5373880., 5397600.,
      6545050., 6575300., 6605550., 6635800., 6704250., 6735300., 6766350.,
      6797400., 3763270., 3782140., 3801010., 3819880., 6386280., 6415120.,
      6443960., 6472800., 7818650., 7855300., 7891950., 7928600., 7977850.,
      8015300., 8052750., 8090200., 4465990., 4488700., 4511410., 4534120.,
      2478680., 2497520., 2516360., 2535200., 2955670., 2979580., 3003490.,
      3027400., 3012790., 3037180., 3061570., 3085960., 1585290., 1600068.,
      1614846., 1629624.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2007850., 2015300., 2022750., 2030200., 2167050., 2175300., 2183550.,
      2191800., 3281450., 3295300., 3309150., 3323000., 3440650., 3455300.,
      3469950., 3484600., 4555050., 4575300., 4595550., 4615800., 4714250.,
      4735300., 4756350., 4777400., 8375850., 8415300., 8454750., 8494200.,
      8535050., 8575300., 8615550., 8655800., 5973290., 6008900., 6044510.,
      6080120., 6132490., 6168900., 6205310., 6241720., 2352170., 2373700.,
      2395230., 2416760., 2511370., 2533700., 2556030., 2578360., 4555050.,
      4575300., 4595550., 4615800., 4714250., 4735300., 4756350., 4777400.,
      5828650., 5855300., 5881950., 5908600., 5987850., 6015300., 6042750.,
      6070200., 7102250., 7135300., 7168350., 7201400., 7261450., 7295300.,
      7329150., 7363000.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5500.,  7180.,  7800.,  8420.,  4934.,  10800., 13600., 14250., 14900.,
      8530.,  16200., 20100., 20750., 21400., 12130., 21600., 26600., 27250.,
      27900., 15730., 8830.,  10610., 10850., 11090., 5913.,  31100., 38180.,
      38800., 39420., 22334., 37800., 46100., 46750., 47400., 26530., 43200.,
      52600., 53250., 53900., 30130., 48600., 59100., 59750., 60400., 33730.,
      19030., 22610., 22850., 23090., 12213., 56700., 69180., 69800., 70420.,
      39734., 64800., 78600., 79250., 79900., 44530., 70200., 85100., 85750.,
      86400., 48130., 75600., 91600., 92250., 92900., 51730., 29230., 34610.,
      34850., 35090., 18513.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x10x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10025., 10675., 11325., 16525., 17175., 17825., 23025., 23675., 24325.,
      42525., 43175., 43825., 49025., 49675., 50325., 55525., 56175., 56825.,
      75025., 75675., 76325., 81525., 82175., 82825., 88025., 88675., 89325.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10720.,  11000.,  13980.,  14360.,  15180.,  15600.,  16380.,  16840.,
      9580.,   9868.,   20950.,  21600.,  26350.,  27200.,  27600.,  28500.,
      28850.,  29800.,  16475.,  17060.,  31350.,  32400.,  38850.,  40200.,
      40100.,  41500.,  41350.,  42800.,  23375.,  24260.,  41750.,  43200.,
      51350.,  53200.,  52600.,  54500.,  53850.,  55800.,  30275.,  31460.,
      16670.,  17660.,  19960.,  21220.,  20410.,  21700.,  20860.,  22180.,
      11025.,  11826.,  60320.,  62200.,  73980.,  76360.,  75180.,  77600.,
      76380.,  78840.,  43180.,  44668.,  72950.,  75600.,  88850.,  92200.,
      90100.,  93500.,  91350.,  94800.,  50975.,  53060.,  83350.,  86400.,
      101350., 105200., 102600., 106500., 103850., 107800., 57875.,  60260.,
      93750.,  97200.,  113850., 118200., 115100., 119500., 116350., 120800.,
      64775.,  67460.,  35870.,  38060.,  42460.,  45220.,  42910.,  45700.,
      43360.,  46180.,  22725.,  24426.,  109920., 113400., 133980., 138360.,
      135180., 139600., 136380., 140840., 76780.,  79468.,  124950., 129600.,
      151350., 157200., 152600., 158500., 153850., 159800., 85475.,  89060.,
      135350., 140400., 163850., 170200., 165100., 171500., 166350., 172800.,
      92375.,  96260.,  145750., 151200., 176350., 183200., 177600., 184500.,
      178850., 185800., 99275.,  103460., 55070.,  58460.,  64960.,  69220.,
      65410.,  69700.,  65860.,  70180.,  34425.,  37026.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x10x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19475.,  20050.,  20725.,  21350.,  21975.,  22650.,  31975.,  33050.,
      33225.,  34350.,  34475.,  35650.,  44475.,  46050.,  45725.,  47350.,
      46975.,  48650.,  81975.,  85050.,  83225.,  86350.,  84475.,  87650.,
      94475.,  98050.,  95725.,  99350.,  96975.,  100650., 106975., 111050.,
      108225., 112350., 109475., 113650., 144475., 150050., 145725., 151350.,
      146975., 152650., 156975., 163050., 158225., 164350., 159475., 165650.,
      169475., 176050., 170725., 177350., 171975., 178650.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21160.,  21440.,  21720.,  22000.,  27580.,  27960.,  28340.,  28720.,
      29940.,  30360.,  30780.,  31200.,  32300.,  32760.,  33220.,  33680.,
      18872.,  19160.,  19448.,  19736.,  41250.,  41900.,  42550.,  43200.,
      51850.,  52700.,  53550.,  54400.,  54300.,  55200.,  56100.,  57000.,
      56750.,  57700.,  58650.,  59600.,  32365.,  32950.,  33535.,  34120.,
      61650.,  62700.,  63750.,  64800.,  76350.,  77700.,  79050.,  80400.,
      78800.,  80200.,  81600.,  83000.,  81250.,  82700.,  84150.,  85600.,
      45865.,  46750.,  47635.,  48520.,  82050.,  83500.,  84950.,  86400.,
      100850., 102700., 104550., 106400., 103300., 105200., 107100., 109000.,
      105750., 107700., 109650., 111600., 59365.,  60550.,  61735.,  62920.,
      32350.,  33340.,  34330.,  35320.,  38660.,  39920.,  41180.,  42440.,
      39530.,  40820.,  42110.,  43400.,  40400.,  41720.,  43040.,  44360.,
      21249.,  22050.,  22851.,  23652.,  118760., 120640., 122520., 124400.,
      145580., 147960., 150340., 152720., 147940., 150360., 152780., 155200.,
      150300., 152760., 155220., 157680., 84872.,  86360.,  87848.,  89336.,
      143250., 145900., 148550., 151200., 174350., 177700., 181050., 184400.,
      176800., 180200., 183600., 187000., 179250., 182700., 186150., 189600.,
      99865.,  101950., 104035., 106120., 163650., 166700., 169750., 172800.,
      198850., 202700., 206550., 210400., 201300., 205200., 209100., 213000.,
      203750., 207700., 211650., 215600., 113365., 115750., 118135., 120520.,
      184050., 187500., 190950., 194400., 223350., 227700., 232050., 236400.,
      225800., 230200., 234600., 239000., 228250., 232700., 237150., 241600.,
      126865., 129550., 132235., 134920., 69550.,  71740.,  73930.,  76120.,
      82160.,  84920.,  87680.,  90440.,  83030.,  85820.,  88610.,  91400.,
      83900.,  86720.,  89540.,  92360.,  43749.,  45450.,  47151.,  48852.,
      216360., 219840., 223320., 226800., 263580., 267960., 272340., 276720.,
      265940., 270360., 274780., 279200., 268300., 272760., 277220., 281680.,
      150872., 153560., 156248., 158936., 245250., 249900., 254550., 259200.,
      296850., 302700., 308550., 314400., 299300., 305200., 311100., 317000.,
      301750., 307700., 313650., 319600., 167365., 170950., 174535., 178120.,
      265650., 270700., 275750., 280800., 321350., 327700., 334050., 340400.,
      323800., 330200., 336600., 343000., 326250., 332700., 339150., 345600.,
      180865., 184750., 188635., 192520., 286050., 291500., 296950., 302400.,
      345850., 352700., 359550., 366400., 348300., 355200., 362100., 369000.,
      350750., 357700., 364650., 371600., 194365., 198550., 202735., 206920.,
      106750., 110140., 113530., 116920., 125660., 129920., 134180., 138440.,
      126530., 130820., 135110., 139400., 127400., 131720., 136040., 140360.,
      66249.,  68850.,  71451.,  74052.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x10x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38375.,  38950.,  39525.,  40100.,  40825.,  41450.,  42075.,  42700.,
      43275.,  43950.,  44625.,  45300.,  62875.,  63950.,  65025.,  66100.,
      65325.,  66450.,  67575.,  68700.,  67775.,  68950.,  70125.,  71300.,
      87375.,  88950.,  90525.,  92100.,  89825.,  91450.,  93075.,  94700.,
      92275.,  93950.,  95625.,  97300.,  160875., 163950., 167025., 170100.,
      163325., 166450., 169575., 172700., 165775., 168950., 172125., 175300.,
      185375., 188950., 192525., 196100., 187825., 191450., 195075., 198700.,
      190275., 193950., 197625., 201300., 209875., 213950., 218025., 222100.,
      212325., 216450., 220575., 224700., 214775., 218950., 223125., 227300.,
      283375., 288950., 294525., 300100., 285825., 291450., 297075., 302700.,
      288275., 293950., 299625., 305300., 307875., 313950., 320025., 326100.,
      310325., 316450., 322575., 328700., 312775., 318950., 325125., 331300.,
      332375., 338950., 345525., 352100., 334825., 341450., 348075., 354700.,
      337275., 343950., 350625., 357300.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42944.,  56080.,  60960.,  65840.,  38560.,  84580.,  106475., 111575.,
      116675., 66725.,  126980., 157475., 162575., 167675., 94925.,  169380.,
      208475., 213575., 218675., 123125., 68468.,  82135.,  83995.,  85855.,
      45585.,  244544., 300080., 304960., 309840., 175360., 296580., 361475.,
      366575., 371675., 207725., 338980., 412475., 417575., 422675., 235925.,
      381380., 463475., 468575., 473675., 264125., 147668., 175135., 176995.,
      178855., 94185.,  446144., 544080., 548960., 553840., 312160., 508580.,
      616475., 621575., 626675., 348725., 550980., 667475., 672575., 677675.,
      376925., 593380., 718475., 723575., 728675., 405125., 226868., 268135.,
      269995., 271855., 142785.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x10x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      78425.,  83525.,  88625.,  129425., 134525., 139625., 180425.,
      185525., 190625., 333425., 338525., 343625., 384425., 389525.,
      394625., 435425., 440525., 445625., 588425., 593525., 598625.,
      639425., 644525., 649625., 690425., 695525., 700625.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84784.,   85888.,   110660.,  112160.,  120260.,  121920.,  129860.,
      131680.,  75980.,   77120.,   166580.,  169160.,  209575.,  212950.,
      219575.,  223150.,  229575.,  233350.,  131125.,  133450.,  249780.,
      253960.,  309575.,  314950.,  319575.,  325150.,  329575.,  335350.,
      186325.,  189850.,  332980.,  338760.,  409575.,  416950.,  419575.,
      427150.,  429575.,  437350.,  241525.,  246250.,  132988.,  136936.,
      159245.,  164270.,  162845.,  167990.,  166445.,  171710.,  87975.,
      91170.,   481584.,  489088.,  590660.,  600160.,  600260.,  609920.,
      609860.,  619680.,  344780.,  350720.,  582580.,  593160.,  709575.,
      722950.,  719575.,  733150.,  729575.,  743350.,  407125.,  415450.,
      665780.,  677960.,  809575.,  824950.,  819575.,  835150.,  829575.,
      845350.,  462325.,  471850.,  748980.,  762760.,  909575.,  926950.,
      919575.,  937150.,  929575.,  947350.,  517525.,  528250.,  286588.,
      295336.,  339245.,  350270.,  342845.,  353990.,  346445.,  357710.,
      181575.,  188370.,  878384.,  892288.,  1070660., 1088160., 1080260.,
      1097920., 1089860., 1107680., 613580.,  624320.,  998580.,  1017160.,
      1209575., 1232950., 1219575., 1243150., 1229575., 1253350., 683125.,
      697450.,  1081780., 1101960., 1309575., 1334950., 1319575., 1345150.,
      1329575., 1355350., 738325.,  753850.,  1164980., 1186760., 1409575.,
      1436950., 1419575., 1447150., 1429575., 1457350., 793525.,  810250.,
      440188.,  453736.,  519245.,  536270.,  522845.,  539990.,  526445.,
      543710.,  275175.,  285570.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x10x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      154575.,  156850.,  164575.,  167050.,  174575.,  177250.,  254575.,
      258850.,  264575.,  269050.,  274575.,  279250.,  354575.,  360850.,
      364575.,  371050.,  374575.,  381250.,  654575.,  666850.,  664575.,
      677050.,  674575.,  687250.,  754575.,  768850.,  764575.,  779050.,
      774575.,  789250.,  854575.,  870850.,  864575.,  881050.,  874575.,
      891250.,  1154575., 1176850., 1164575., 1187050., 1174575., 1197250.,
      1254575., 1278850., 1264575., 1289050., 1274575., 1299250., 1354575.,
      1380850., 1364575., 1391050., 1374575., 1401250.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      168464.,  169568.,  170672.,  171776.,  219820.,  221320.,  222820.,
      224320.,  238860.,  240520.,  242180.,  243840.,  257900.,  259720.,
      261540.,  263360.,  150820.,  151960.,  153100.,  154240.,  330580.,
      333160.,  335740.,  338320.,  415775.,  419150.,  422525.,  425900.,
      435575.,  439150.,  442725.,  446300.,  455375.,  459150.,  462925.,
      466700.,  259925.,  262250.,  264575.,  266900.,  495380.,  499560.,
      503740.,  507920.,  613775.,  619150.,  624525.,  629900.,  633575.,
      639150.,  644725.,  650300.,  653375.,  659150.,  664925.,  670700.,
      369125.,  372650.,  376175.,  379700.,  660180.,  665960.,  671740.,
      677520.,  811775.,  819150.,  826525.,  833900.,  831575.,  839150.,
      846725.,  854300.,  851375.,  859150.,  866925.,  874700.,  478325.,
      483050.,  487775.,  492500.,  262028.,  265976.,  269924.,  273872.,
      313465.,  318490.,  323515.,  328540.,  320545.,  325690.,  330835.,
      335980.,  327625.,  332890.,  338155.,  343420.,  172755.,  175950.,
      179145.,  182340.,  955664.,  963168.,  970672.,  978176.,  1171820.,
      1181320., 1190820., 1200320., 1190860., 1200520., 1210180., 1219840.,
      1209900., 1219720., 1229540., 1239360., 683620.,  689560.,  695500.,
      701440.,  1154580., 1165160., 1175740., 1186320., 1405775., 1419150.,
      1432525., 1445900., 1425575., 1439150., 1452725., 1466300., 1445375.,
      1459150., 1472925., 1486700., 805925.,  814250.,  822575.,  830900.,
      1319380., 1331560., 1343740., 1355920., 1603775., 1619150., 1634525.,
      1649900., 1623575., 1639150., 1654725., 1670300., 1643375., 1659150.,
      1674925., 1690700., 915125.,  924650.,  934175.,  943700.,  1484180.,
      1497960., 1511740., 1525520., 1801775., 1819150., 1836525., 1853900.,
      1821575., 1839150., 1856725., 1874300., 1841375., 1859150., 1876925.,
      1894700., 1024325., 1035050., 1045775., 1056500., 564428.,  573176.,
      581924.,  590672.,  667465.,  678490.,  689515.,  700540.,  674545.,
      685690.,  696835.,  707980.,  681625.,  692890.,  704155.,  715420.,
      356355.,  363150.,  369945.,  376740.,  1742864., 1756768., 1770672.,
      1784576., 2123820., 2141320., 2158820., 2176320., 2142860., 2160520.,
      2178180., 2195840., 2161900., 2179720., 2197540., 2215360., 1216420.,
      1227160., 1237900., 1248640., 1978580., 1997160., 2015740., 2034320.,
      2395775., 2419150., 2442525., 2465900., 2415575., 2439150., 2462725.,
      2486300., 2435375., 2459150., 2482925., 2506700., 1351925., 1366250.,
      1380575., 1394900., 2143380., 2163560., 2183740., 2203920., 2593775.,
      2619150., 2644525., 2669900., 2613575., 2639150., 2664725., 2690300.,
      2633375., 2659150., 2684925., 2710700., 1461125., 1476650., 1492175.,
      1507700., 2308180., 2329960., 2351740., 2373520., 2791775., 2819150.,
      2846525., 2873900., 2811575., 2839150., 2866725., 2894300., 2831375.,
      2859150., 2886925., 2914700., 1570325., 1587050., 1603775., 1620500.,
      866828.,  880376.,  893924.,  907472.,  1021465., 1038490., 1055515.,
      1072540., 1028545., 1045690., 1062835., 1079980., 1035625., 1052890.,
      1070155., 1087420., 539955.,  550350.,  560745.,  571140.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x10x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      306875.,  309150.,  311425.,  313700.,  326675.,  329150.,  331625.,
      334100.,  346475.,  349150.,  351825.,  354500.,  504875.,  509150.,
      513425.,  517700.,  524675.,  529150.,  533625.,  538100.,  544475.,
      549150.,  553825.,  558500.,  702875.,  709150.,  715425.,  721700.,
      722675.,  729150.,  735625.,  742100.,  742475.,  749150.,  755825.,
      762500.,  1296875., 1309150., 1321425., 1333700., 1316675., 1329150.,
      1341625., 1354100., 1336475., 1349150., 1361825., 1374500., 1494875.,
      1509150., 1523425., 1537700., 1514675., 1529150., 1543625., 1558100.,
      1534475., 1549150., 1563825., 1578500., 1692875., 1709150., 1725425.,
      1741700., 1712675., 1729150., 1745625., 1762100., 1732475., 1749150.,
      1765825., 1782500., 2286875., 2309150., 2331425., 2353700., 2306675.,
      2329150., 2351625., 2374100., 2326475., 2349150., 2371825., 2394500.,
      2484875., 2509150., 2533425., 2557700., 2504675., 2529150., 2553625.,
      2578100., 2524475., 2549150., 2573825., 2598500., 2682875., 2709150.,
      2735425., 2761700., 2702675., 2729150., 2755625., 2782100., 2722475.,
      2749150., 2775825., 2802500.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      339360.,  443240.,  481960.,  520680.,  304856.,  669400.,  842550.,
      882950.,  923350.,  527770.,  1005400., 1246550., 1286950., 1327350.,
      750970.,  1341400., 1650550., 1690950., 1731350., 974170.,  539080.,
      646130.,  660770.,  675410.,  357822.,  1939360., 2379240., 2417960.,
      2456680., 1389656., 2349400., 2862550., 2902950., 2943350., 1643770.,
      2685400., 3266550., 3306950., 3347350., 1866970., 3021400., 3670550.,
      3710950., 3751350., 2090170., 1163080., 1378130., 1392770., 1407410.,
      739422.,  3539360., 4315240., 4353960., 4392680., 2474456., 4029400.,
      4882550., 4922950., 4963350., 2759770., 4365400., 5286550., 5326950.,
      5367350., 2982970., 4701400., 5690550., 5730950., 5771350., 3206170.,
      1787080., 2110130., 2124770., 2139410., 1121022.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x10x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      620350.,  660750.,  701150.,  1024350., 1064750., 1105150., 1428350.,
      1468750., 1509150., 2640350., 2680750., 2721150., 3044350., 3084750.,
      3125150., 3448350., 3488750., 3529150., 4660350., 4700750., 4741150.,
      5064350., 5104750., 5145150., 5468350., 5508750., 5549150.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      674336.,   678720.,   880520.,   886480.,   957320.,   963920.,
      1034120.,  1041360.,  605176.,   609712.,   1328520.,  1338800.,
      1671650.,  1685100.,  1751650.,  1765900.,  1831650.,  1846700.,
      1046270.,  1055540.,  1994120.,  2010800.,  2471650.,  2493100.,
      2551650.,  2573900.,  2631650.,  2654700.,  1487870.,  1501940.,
      2659720.,  2682800.,  3271650.,  3301100.,  3351650.,  3381900.,
      3431650.,  3462700.,  1929470.,  1948340.,  1062392.,  1078160.,
      1272190.,  1292260.,  1300990.,  1321540.,  1329790.,  1350820.,
      702882.,   715644.,   3848736.,  3878720.,  4720520.,  4758480.,
      4797320.,  4835920.,  4874120.,  4913360.,  2755576.,  2779312.,
      4656520.,  4698800.,  5671650.,  5725100.,  5751650.,  5805900.,
      5831650.,  5886700.,  3254270.,  3287540.,  5322120.,  5370800.,
      6471650.,  6533100.,  6551650.,  6613900.,  6631650.,  6694700.,
      3695870.,  3733940.,  5987720.,  6042800.,  7271650.,  7341100.,
      7351650.,  7421900.,  7431650.,  7502700.,  4137470.,  4180340.,
      2291192.,  2326160.,  2712190.,  2756260.,  2740990.,  2785540.,
      2769790.,  2814820.,  1451682.,  1478844.,  7023136.,  7078720.,
      8560520.,  8630480.,  8637320.,  8707920.,  8714120.,  8785360.,
      4905976.,  4948912.,  7984520.,  8058800.,  9671650.,  9765100.,
      9751650.,  9845900.,  9831650.,  9926700.,  5462270.,  5519540.,
      8650120.,  8730800.,  10471650., 10573100., 10551650., 10653900.,
      10631650., 10734700., 5903870.,  5965940.,  9315720.,  9402800.,
      11271650., 11381100., 11351650., 11461900., 11431650., 11542700.,
      6345470.,  6412340.,  3519992.,  3574160.,  4152190.,  4220260.,
      4180990.,  4249540.,  4209790.,  4278820.,  2200482.,  2242044.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x10x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1231650.,  1240700.,  1311650.,  1321500.,  1391650.,  1402300.,
      2031650.,  2048700.,  2111650.,  2129500.,  2191650.,  2210300.,
      2831650.,  2856700.,  2911650.,  2937500.,  2991650.,  3018300.,
      5231650.,  5280700.,  5311650.,  5361500.,  5391650.,  5442300.,
      6031650.,  6088700.,  6111650.,  6169500.,  6191650.,  6250300.,
      6831650.,  6896700.,  6911650.,  6977500.,  6991650.,  7058300.,
      9231650.,  9320700.,  9311650.,  9401500.,  9391650.,  9482300.,
      10031650., 10128700., 10111650., 10209500., 10191650., 10290300.,
      10831650., 10936700., 10911650., 11017500., 10991650., 11098300.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, SAME3x10x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1344288., 1348672., 1353056., 1357440., 1755080., 1761040., 1767000.,
      1772960., 1908040., 1914640., 1921240., 1927840., 2061000., 2068240.,
      2075480., 2082720., 1205816., 1210352., 1214888., 1219424., 2646760.,
      2657040., 2667320., 2677600., 3329850., 3343300., 3356750., 3370200.,
      3489050., 3503300., 3517550., 3531800., 3648250., 3663300., 3678350.,
      3693400., 2083270., 2092540., 2101810., 2111080., 3971560., 3988240.,
      4004920., 4021600., 4921850., 4943300., 4964750., 4986200., 5081050.,
      5103300., 5125550., 5147800., 5240250., 5263300., 5286350., 5309400.,
      2961670., 2975740., 2989810., 3003880., 5296360., 5319440., 5342520.,
      5365600., 6513850., 6543300., 6572750., 6602200., 6673050., 6703300.,
      6733550., 6763800., 6832250., 6863300., 6894350., 6925400., 3840070.,
      3858940., 3877810., 3896680., 2109016., 2124784., 2140552., 2156320.,
      2524310., 2544380., 2564450., 2584520., 2581430., 2601980., 2622530.,
      2643080., 2638550., 2659580., 2680610., 2701640., 1393002., 1405764.,
      1418526., 1431288., 4661024., 4682816., 4704608., 4726400., 5726920.,
      5754640., 5782360., 5810080., 5879880., 5908240., 5936600., 5964960.,
      4791752., 4816656., 4841560., 4866464., 2270008., 2283504., 2297000.,
      2310496., 2217448., 2235152., 2252856., 2270560., 2718970., 2741700.,
      2764430., 2787160., 2878170., 2901700., 2925230., 2948760., 2451642.,
      2471876., 2492110., 2512344., 1172998., 1183740., 1194482., 1205224.,
      2116840., 2124560., 2132280., 2140000., 2693050., 2703300., 2713550.,
      2723800., 2852250., 2863300., 2874350., 2885400., 3011450., 3023300.,
      3035150., 3047000., 1731910., 1739260., 1746610., 1753960., 3441640.,
      3455760., 3469880., 3484000., 4285050., 4303300., 4321550., 4339800.,
      4444250., 4463300., 4482350., 4501400., 4603450., 4623300., 4643150.,
      4663000., 2610310., 2622460., 2634610., 2646760., 1426264., 1436656.,
      1447048., 1457440., 1724630., 1737980., 1751330., 1764680., 1781750.,
      1795580., 1809410., 1823240., 1838870., 1853180., 1867490., 1881800.,
      977706.,  986436.,  995166.,  1003896., 5896992., 5919808., 5942624.,
      5965440., 7261640., 7290640., 7319640., 7348640., 7414600., 7444240.,
      7473880., 7503520., 7567560., 7597840., 7628120., 7658400., 4288568.,
      4306928., 4325288., 4343648., 7416040., 7449360., 7482680., 7516000.,
      9061050., 9103300., 9145550., 9187800., 7651482., 7690436., 7729390.,
      7768344., 6372986., 6408644., 6444302., 6479960., 3138118., 3158524.,
      3178930., 3199336., 3383272., 3406608., 3429944., 3453280., 4119930.,
      4149700., 4179470., 4209240., 3365722., 3392196., 3418670., 3445144.,
      2742586., 2765764., 2788942., 2812120., 1276294., 1289212., 1302130.,
      1315048., 1971944., 1985296., 1998648., 2012000., 2455610., 2472900.,
      2490190., 2507480., 2356762., 2370756., 2384750., 2398744., 2388986.,
      2399684., 2410382., 2421080., 1380550., 1385980., 1391410., 1396840.,
      743512.,  748528.,  753544.,  758560.,  924950.,  931580.,  938210.,
      944840.,  982070.,  989180.,  996290.,  1003400., 1039190., 1046780.,
      1054370., 1061960., 562410.,  567108.,  571806.,  576504.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow5Stride2, VALID3x10x10x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2454250., 2463300., 2472350., 2481400., 2613450., 2623300., 2633150.,
      2643000., 2772650., 2783300., 2793950., 2804600., 4046250., 4063300.,
      4080350., 4097400., 4205450., 4223300., 4241150., 4259000., 4364650.,
      4383300., 4401950., 4420600., 5638250., 5663300., 5688350., 5713400.,
      5797450., 5823300., 5849150., 5875000., 5956650., 5983300., 6009950.,
      6036600., 3881130., 3909700., 3938270., 3966840., 4040330., 4069700.,
      4099070., 4128440., 3726442., 3754564., 3782686., 3810808., 2216810.,
      2232900., 2248990., 2265080., 2376010., 2392900., 2409790., 2426680.,
      2389802., 2405444., 2421086., 2436728., 3409450., 3423300., 3437150.,
      3451000., 3568650., 3583300., 3597950., 3612600., 3727850., 3743300.,
      3758750., 3774200., 8185450., 8223300., 8261150., 8299000., 8344650.,
      8383300., 8421950., 8460600., 8503850., 8543300., 8582750., 8622200.,
      6101290., 6136900., 6172510., 6208120., 5623562., 5657924., 5692286.,
      5726648., 4607210., 4638276., 4669342., 4700408., 2798570., 2821700.,
      2844830., 2867960., 2648522., 2670404., 2692286., 2714168., 2287530.,
      2306116., 2324702., 2343288.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}